Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Rtp Class Reference

<class description="" goes="" here=""> <short description=""> More...

#include <Rtp.hpp>

Inheritance diagram for Rtp:

List of all members.

Public Member Functions
	Rtp (const char *url, int remotePrt, const char *address, int localPrt, ESInfo *es, PacketizationLayer *packetization, bool writeOnly, const TerminalCapabilities *tc, GlobalTimer *globalTimer, Statistics *statistics, bool allowVopTimeDetection=true)
	creates an RTP object
Statistics *	getStatistics ()
void	setESInfo (ESInfo *new_es)
ESInfo *	getESInfo ()
Frame *	getFrame ()
	returns a frame if one complete frame is available, otherwise null is returned.
int	writeFrame (Frame *frm, ESInfo *out_es=NULL)
	just adds a frame to the send buffer.
void	resendHeader ()
	if this is called, the next sent frame will also include a decoder header this could be used for multicast sessions
void	run ()
	this thread works on the read buffer, using the estimated avail.
bool	open ()
	opens the IO connection.
State	play (double prefetchTime)
State	pause ()
State	mute ()
bool	close (bool immediate=false)
	closes the IO class.
int	getLocalPort () const
int	getBufferFillLevelInPercent () const
	returns preQ buffer fill in percent
int	getBufferFillLevel () const
	returns a value from 0..100 indicating buffer usage
int	getBufferFillLevelInBytes () const
	returns preQ buffer fill in Bytes
int	flushBuffer (long from_ts=0, long to_ts=-1)
	flushes the preQ buffer from starting TimeStamp to end TS
bool	isInput ()
bool	isOutput ()
bool	destroy ()
	you can't delete a remote url :-) will always return true
const char *	getURL () const
	returns a pointer to the local file name or an URL
char *	getSSRC ()
	returns NULL if the session was not opened, Otherwise, a char* containing a 08x hexValue
void	setRtxInfo (const rtx_info *rtx)
	sets a shallow copy of
const rtx_info *	getRtxInfo () const
bool	setToFrameNumber (u32 frameNumber)
	repositions the IO class to the given frame.
bool	setEndFrameNumber (u32 frameNumber)
	sets the last frame that should be sent.
Protected Types
typedef Rtp::NetPacket_t	NetPacket_t
enum	QOrder { Q_HEAD, Q_TAIL, Q_TS, Q_SEQ }
Protected Member Functions
bool	insertToPreQ (u8 *payload, long pl_size, Frame::FrameType type, long vop_size, int prio, u32 rtpTimestamp, u32 fragCounter, bool lastFrag, u32 rtp_seq, QOrder qo)
	inserts an SL packet to the preQ in the given order
bool	reinsertToPreQ (NetPacket_t *p, uint rtp_seq)
	reinserts a SL packet for retransmission to the head of the preQ
bool	addToPreQ (NetPacket_t *p, QOrder qo, bool pushback=false)
	adds a NetPacket to the head or tail of the preQ (this is used from insertToPreQ or for retransmissions) or sorted by a frames' timestamp (used for receiving RTP)
NetPacket_t *	popPreQ (bool blocking=true)
	block or get the first packet off the preQ this does neither free the packet, nor the packet payload!
void	calcAdaptPreQValues (int net_bw)
	it decides, how many stream seconds should be brought thru in this second (this is needed to fill up the buffers or send a better quality even if the network does not allow it --> only if client buffers are full!) it also sets the percentage of adaptation
void	markFullFramePartially (bool dropped, bool sent, u32 ts)
	searches all packets with the same TS (so they belong to one single frame) and marks them all as partially_dropped or partially_sent this is used for better adaptPreQ() results (it has to adapt full frames, not packets)
void	adaptPreQ (int net_bw)
	marks unimportant packets for the next streamout sec, according to their priority marks packets for the next streamout second starting from the preQ head.
int	getNextPreQ_TS ()
bool	pushNetPacket (NetPacket_t *p)
NetPacket_t *	popNetPacket (uint16_t rtp_seq)
NetPacket_t *	popNetPacketByRTXseq (uint16_t rtx_rtp_seq)
void	sendQupdate (long streamout_sec)
	scans the SendQ for already ack'd or out-dated frames and releases them.
void	preQupdate ()
	scans the preQ for missing packets and requests their retransmission since in the client, not frame type is known, EVERY missing packet is reqeusted...
int	doSend (NetPacket_t *p)
void	sendThread ()
void	readThread ()
void	ucl_update (u32 ts, u32 timeout)
	calls UCL lib for RTP,RTCP updates and callback functions (recv data)
Static Protected Member Functions
void	RtpCallback (struct rtp *session, rtp_event *e)
void	fb_print (struct rtp *session, uint32_t ssrc, rtcp_fb *fb)
void	fb_handle (struct rtp *session, uint32_t ssrc, rtcp_fb *fb)
void	rtp_data_handle (struct rtp *session, uint32_t ssrc, rtp_packet *packet)
Protected Attributes
Rtp::PreQ_t	preQ
Rtp::SendQ_t	sendQ
Statistics *	stats
rtp *	session
uint32_t	sender_ssrc
int	remotePort
int	localPort
char *	remoteAddress
bool	writeToNetwork
bool	firstFrame
struct {
int   numProcessedFrames
int   seqno
int   act_ts
}	IOFrameStat
GlobalTimer *	globalTimer
PacketizationLayer *	pLayer
ESInfo *	es
char *	url
rtx_info *	rtx
bool	feedbackEnabled
bool	rtxEnabled
int64_t	last_rr_seq_no
int64_t	last_rr_sum_pkts_lost
double	last_rr_lost_fract
double	last_rr_received
int64_t	first_rtp_seq
uint16_t	last_rtp_seq
int	ts_offset
int64_t	first_rtx_rtp_seq
uint16_t	last_rtx_rtp_seq
int	interarrival_time
int	net_bw_before_superdrain
int	real_bw
bool	threadWasPaused
bool	allowVopTimeDetection
Static Protected Attributes
const int	TTL = 16
const int	MAX_PAYLOAD_SIZE = 65000
const int	RTP_PAYLOAD_TYPE = 96

---

Detailed Description

<class description="" goes="" here=""> <short description="">

Author:

Michael Kropfberger and Peter Schojer

Version:

Id

Rtp.hpp,v 1.30 2006/01/26 11:42:00 mkropfbe Exp

Definition at line 108 of file Rtp.hpp.

---

Constructor & Destructor Documentation

Rtp::Rtp (  const char *  url, int  remotePrt, const char *  address, int  localPrt, ESInfo *  es, PacketizationLayer *  packetization, bool  writeOnly, const TerminalCapabilities *  tc, GlobalTimer *  globalTimer, Statistics *  statistics, bool  allowVopTimeDetection = true )

creates an RTP object Parameters: url:  the source/dest for this IO class, deep-copied remotePrt:  the remote port where data is sent to address:  the ip address of the remote host, deep-copied localPrt:  the local port, where we are binding and receiving es:  the ElementaryStream sent, shallow-copied packetization:  specifies the transport mode: can be RFC3016, multiSL or flexmux writeonly  specifies if the RTP connection is for sending (writeonly is set to true), of for reading tc:  the TerminalCapabilities, shallow-copied (eg. RTX on/off) allowVopTimeDetection:  if set to true (default), allows rtp to detect and CHANGE the VOPTIMEincrement for the ESInfo object Definition at line 133 of file Rtp.cpp. References Statistics::getBaseStreamBW(), TerminalCapabilities::getNetworkCapacityInByte(), Statistics::getStreamBW(), Statistics::setBaseStreamBW(), and IO::setState(). : IO() { assert(e); assert(p); assert(uri && addr); allowVopTimeDetection=avtd; url = new char[strlen(uri) + 1]; rtx=NULL; remotePort = remotePrt; remoteAddress = new char[strlen(addr) + 1]; localPort = localPrt; globalTimer = gt; stats = statistics; writeToNetwork = w; strcpy(remoteAddress, addr); strcpy(url, uri); setState(CLOSED); session = NULL; pLayer = p; firstFrame=false; // must use open to set to true memset(&sendQ.Q,0,sizeof(sendQ.Q)); preQ.Q = preQ.Q_tail = NULL; sendQ.size = preQ.size = 0; resendFrameHeader=false; preQ.needsPrefetching=false; //initial prefetching autodetected preQ.MUTEX_Q.initialize("RTP-preQ.MUTEX_Q"); preQ.MUTEX_Q_DATA_AVAIL.initialize("RTP-preQ.MUTEX_Q_DATA_AVAIL"); preQ.MUTEX_Q_DATA_AVAIL.lock(); preQ.MUTEX_Q_FULL.initialize("RTP-preQ.MUTEX_Q_FULL"); preQ.MUTEX_Q_DONE.initialize("RTP-preQ.MUTEX_Q_DONE"); preQ.MUTEX_Q_DONE.lock(); sendQ.MUTEX_Q.initialize("RTP-sendQ.MUTEX_Q"); last_rr_seq_no = -1; last_rr_sum_pkts_lost = -1; last_rtp_seq=0; last_rtx_rtp_seq=0; interarrival_time=0; //net_bw_before_superdrain=-1; real_bw=0; first_rtp_seq = -1; first_rtx_rtp_seq = -1; ts_offset = 0; feedbackEnabled = false; rtxEnabled = false; threadWasPaused=false; this->setESInfo(e); if(tc) stats->setBaseStreamBW(tc->getNetworkCapacityInByte()); //set base, unaffected by switching else stats->setBaseStreamBW(stats->getStreamBW()); //set base, unaffected by switching dprintf_full("Rtp::Rtp (url=%s, remotePort=%i, remoteAddr=%s, localPort=%i, writeOnly=%i, avgBW=%i, TCbw=%i)\r\n", url, remotePort,remoteAddress,localPort,(int)writeToNetwork,stats->getStreamBW()/128, stats->getBaseStreamBW()/128 ); }

---

Member Function Documentation

void Rtp::adaptPreQ (  int  net_bw  )  [protected]

marks unimportant packets for the next streamout sec, according to their priority marks packets for the next streamout second starting from the preQ head. if new data or RTX makes the preQ dirty, a new marking is done, now starting at exactly from the new preQ head. RTX is never marked for adaptation. it has to adapt full frames, not packets. to do so, it looks at partially_sent and partially_dropped markers of packets Parameters: net_bw  sets the available bandwidth of the network for the next streamout second Definition at line 2780 of file Rtp.cpp. References Statistics::getAdaptRate(), Statistics::getAdaptSecs(), Statistics::getBufAheadSec(), and Statistics::getStreamBW(). { CompareNetPackets cmpFnc; priority_queue<NetPacket_t*,std::vector<NetPacket_t*>,CompareNetPackets> pq(cmpFnc); int size=0; NetPacket_t *p=NULL, *pp=NULL; dprintf_full("Rtp:adaptPreQ: keeping %2i%% reach netBW %i KBits of streamBW" " %i KBits for %2.3f secs == realBW %i (ClBuf: %2.3f)\n", stats->getAdaptRate(), net_bw*8/1024, stats->getStreamBW()*8/1024, stats->getAdaptSecs(),real_bw/128, stats->getBufAheadSec()); // dprintf_full("Rtp::adaptPreQ waiting for preQ mutex\n"); preQ.MUTEX_Q.lock(); //dprintf_full("Rtp::adaptPreQ got preQ mutex\n"); p=preQ.Q; // read in full streamout block and mark it to non-drop // this includes all partially dropped or sent frame-packets, I_VOPs, P_VOPS.... and RTX // because all of them shall be streamed in the next sec. while (p && (size+p->pl_size <= (unsigned)real_bw)) { pq.push(p); size += p->pl_size; p->drop_me = false; p=p->next; } // chop off the packets to meet the net_bw // we have to ignore partially sent frames and RTX, we force dropping of partially dropped ones while (!pq.empty() && (size > net_bw)) { p=pq.top(); pq.pop(); // if (p->prio == IO_NETWORK_HIGHEST_PRIORITY) { if (p->prio <= RTP_MIN_PRIO) { //keep at least 10 fps //FIXME: what now? switching? dprintf_full("Rtp::adaptPreQ BAILING OUT because below RTP_MIN_PRIO!! (prio %i VOP_type %s TS %i:%i)\n" ,p->prio,Frame::VOPTypeToChar(p->vop_type),p->rtp_ts,p->rtp_seq); break; } if ( ((p->resent_counter == 0) && (!p->partially_sent)) || (p->partially_dropped) ) { //BVOP for first send, so drop it! size -= p->pl_size; //dont reduce size for RTX, so we will adapt more to fit RTX in network p->drop_me = true; dprintf_full("Rtp::adaptPreQ marking prio %i VOP_type %s TS %i:%i for dropping... partially_dropped %i\n",p->prio,Frame::VOPTypeToChar(p->vop_type),p->rtp_ts,p->rtp_seq,p->partially_dropped); } else dprintf_full("Rtp::adaptPreQ NOT marking since its a RTX or partially sent (prio %i VOP_type %s TS %i:%i)\n" ,p->prio,Frame::VOPTypeToChar(p->vop_type),p->rtp_ts,p->rtp_seq); } // DELETE the rest of FULL FRAME // only if B-VOP for first send, if (p && !pq.empty() && (p->prio > RTP_MIN_PRIO) && (p->resent_counter == 0) && (!p->partially_sent) ) { do { pp = pq.top(); pq.pop(); if (pp->rtp_ts == p->rtp_ts) { //no checking on RTX is needed, since list is sorted by TS:seqNo pp->drop_me = true; dprintf_full("Rtp::adaptPreQ rest-marking prio %i VOP_type %s TS %i:%i for dropping...\n",pp->prio,Frame::VOPTypeToChar(p->vop_type),pp->rtp_ts,p->rtp_seq); } else break; } while (!pq.empty() ); } preQ.isDirty = false; preQ.MUTEX_Q.release(); }

void Rtp::calcAdaptPreQValues (  int  net_bw  )  [protected]

it decides, how many stream seconds should be brought thru in this second (this is needed to fill up the buffers or send a better quality even if the network does not allow it --> only if client buffers are full!) it also sets the percentage of adaptation Parameters: net_bw  sets the available bandwidth of the network for the next streamout second Definition at line 2698 of file Rtp.cpp. References Statistics::getAdaptRate(), Statistics::getAdaptSecs(), Statistics::getBufAheadSec(), Statistics::getStreamBW(), Statistics::getStreamoutSec(), Statistics::setAdaptRate(), and Statistics::setAdaptSecs(). { CompareNetPackets cmpFnc; priority_queue<NetPacket_t*,std::vector<NetPacket_t*>,CompareNetPackets> pq(cmpFnc); if (stats->getStreamoutSec() < RTP_PREFETCH_SECS) return; stats->setAdaptSecs(1.0); //normal adaptation if (stats->getBufAheadSec() < RTP_BUF_LOWWATER) { stats->setAdaptSecs(stats->getAdaptSecs() + (float)RTP_BUF_FILL_FACT); //fill buf (eg. 1.10) } if (net_bw_before_superdrain != -1) { //we are in super draining phase dprintf_full("Rtp::calcAdaptPreQValues turning off adaptation, totally use buffer, we have sooo much of it...\n"); real_bw = net_bw; //turn off adaptation, totally use buffer, we have sooo much of it... } else { real_bw = (int)((float)stats->getStreamBW() * stats->getAdaptSecs()); if (real_bw < net_bw) //if buf_drain more than net_bw real_bw = net_bw; //no need to spoil net bw! :) } //if (stats->getAdaptRate(0)) //smoother adapt changes stats->setAdaptRate(net_bw*100 / real_bw); //else // stats->setAdaptRate((int)((float)stats->getAdaptRate()*(1 - 0.3) + (net_bw*100 / real_bw)*0.3) + 1); if (stats->getBufAheadSec() > RTP_BUF_HIGHWATER) { if (net_bw <= stats->getStreamBW()) { //so adaptSecs is < 1.0 stats->setAdaptSecs((float)net_bw / (float)stats->getStreamBW()); real_bw = (int)((float)stats->getStreamBW() * stats->getAdaptSecs()); stats->setAdaptRate(net_bw*100 / real_bw); dprintf_full("Rtp::calcAdaptPreQValues: superdrain mode: TURNING OFF ADAPTATION since we have so much buffer!\n"); } } if ((stats->getBufAheadSec() > RTP_BUF_LOWWATER) && (stats->getAdaptRate() < (float)RTP_MAX_ADAPT/100.0)) { //we have enough buffers to reduce necessary adaptation to B-frames only //stats->setAdaptSecs((float)net_bw / ((float)RTP_MAX_ADAPT/100.0 * (float)stats->getStreamBW())); stats->setAdaptSecs(stats->getAdaptSecs() - (float)RTP_BUF_DRAIN_FACT); //drain buf (eg. 0.70) real_bw = (int)((float)stats->getStreamBW() * stats->getAdaptSecs()); stats->setAdaptRate(net_bw*100 / real_bw); dprintf_full("Rtp::calcAdaptPreQValues: superdrain mode: ACTIVELY DRAINING BUFFER to preserve quality!\n"); } dprintf_full("Rtp:calcAdaptPreQValues: keeping %2i%% reach netBW %i KBits of " "streamBW %i KBits for %2.3f secs == realBW %i (ClBuf: %2.3f)\n", stats->getAdaptRate(), net_bw*8/1024, stats->getStreamBW()*8/1024, stats->getAdaptSecs(),real_bw/128, stats->getBufAheadSec()); }

bool Rtp::close (  bool  immediate = false  )  [virtual]

closes the IO class. Parameters: immediate  specifies, if (optional) buffered data should be read/sent to the client (==false), or immediately dumped (==true) Implements IO. Definition at line 673 of file Rtp.cpp. References PortGenerator::closePortPair(), popPreQ(), sendQupdate(), and IO::setState(). Referenced by getFrame(). { if (state == CLOSED) return true; dprintf_full("Rtp::close: incoming state = %i\n",state); if ((state == CLOSING) && (immediate)) { //multiple closes dprintf_full("Rtp::close: multiple close... ignoring\n"); setState(FORCE_CLOSING); preQ.MUTEX_Q_DONE.release(); //signal that all data is sent sleep(2); //workaround to let datachannel::teardown wait! return true; } if((state == OPEN) || (state == PAUSED) || (state == MUTED) || (state == PREFETCHING) || (state == STREAMEOF)) { if (!immediate) { setState(CLOSING); dprintf_full("Rtp::close waiting for correct sending/displaying (NOT IMMEDIATE)\n"); } else { //drop all frames, is IMMEDIATE dprintf_full("Rtp::close IMMEDIATE close requested\n"); setState(FORCE_CLOSING); } if (immediate) { //drop all frames, is IMMEDIATE NetPacket_t *p; sendQupdate(-1); do { p = popPreQ(false); if ( (p != NULL) && (p->payload != NULL) ) { dprintf_full("freeing preQ Frame seq %i ts %i:%i\n", p->rtp_seq,p->rtp_ts,p->frag_no); delete p->payload; p->payload=NULL; delete p; p=NULL; } } while (p != NULL); preQ.MUTEX_Q_DONE.tryLock(); } dprintf_full("Rtp::close: waiting for data to be sent out...\n"); preQ.MUTEX_Q.lock(); do { if (state == OPEN) //happens after unpause or unmute setState(CLOSING); //if (preQ.Q == NULL) //make sure that other thread in popPreQ exits preQ.MUTEX_Q_DATA_AVAIL.release(); // simulate data preQ.MUTEX_Q.release(); dprintf_full("Rtp::close: give the other thread a chance to work off Q (state %i)\n",state); //give the other thread a chance to work off Q sleep(1); preQ.MUTEX_Q.lock(); } while ((state == CLOSING)||(state == PAUSED)||(state == MUTED)); preQ.MUTEX_Q.release(); if (state == OPEN) //happens on unpausing (hereby rewinding) a already closed inputIO return false; if (state != CLOSED) { // if (preQ.Q == NULL) //make sure that other thread in popPreQ exits preQ.MUTEX_Q_DATA_AVAIL.release(); //simulate data dprintf_full("Rtp::close: waiting for MUTEX_Q_DONE\n"); preQ.MUTEX_Q_DONE.lock(); //wait until all data is sent dprintf_full("Rtp::close: all frames sent, so we are done...\n"); setState(CLOSED); //FIXME: this crashes the app! if(session!=NULL) { rtp_send_bye(session); rtp_done(session); session = NULL; portGen.closePortPair(localPort); } if (rtxEnabled && rtx->session) { rtp_send_bye(rtx->session); rtp_done(rtx->session); rtx->session = NULL; portGen.closePortPair(rtx->localPort); } // now delete mutex preQ.MUTEX_Q.destroy(); preQ.MUTEX_Q_DATA_AVAIL.destroy(); preQ.MUTEX_Q_FULL.destroy(); preQ.MUTEX_Q_DONE.destroy(); sendQ.MUTEX_Q.destroy(); } } return true; }

Frame * Rtp::getFrame (   )  [virtual]

returns a frame if one complete frame is available, otherwise null is returned. This function is typically blocking. Don't use a NULL return value to conclude STREAMEOF, always check with getState()! Implements IO. Definition at line 770 of file Rtp.cpp. References addToPreQ(), close(), flushBuffer(), Frame::getAU(), Statistics::getBufAheadSec(), ESInfo::getDuration(), Statistics::getFirstPacketTime(), Statistics::getFirstPacketTS(), Statistics::getHighestPacketTS(), ESInfo::getMediaTimeScale(), ESInfo::getNumberOfMediaSamples(), Statistics::getPrefetchedSecs(), Statistics::getStillToPrefetchSecs(), Frame::getType(), ESInfo::isAudioStream(), ESInfo::isVisualStream(), popPreQ(), Frame::setAU(), Statistics::setBufAheadSec(), ESInfo::setDecoderConfig(), Frame::setMediaTimeScale(), Statistics::setPrefetchedSecs(), GlobalTimer::setPrefetching(), IO::setState(), and Statistics::setStillToPrefetchSecs(). { struct AU *au=NULL; NetPacket_t *p=NULL; u8 *buf=NULL; long buf_siz=0; bool lastFrag; bool first_frag=true; bool old_ts=false; currentFrameNumber++; framesSeen++; dprintf_full("Rtp::getFrame %i (TS %i) of still buffered %i frames (total %i of %i TS %li)... expecting rtp_seq %i (state %i)\n", IOFrameStat.numProcessedFrames, IOFrameStat.act_ts, preQ.num_full_frames, currentFrameNumber, es->getNumberOfMediaSamples(),(long)es->getDuration(), IOFrameStat.seqno+1,state); //PRE-buffer some frames struct timeval tv; double start_dtime, now_dtime=0,fetch_time=0; IO::State oldState; gettimeofday(&tv,0); start_dtime = now_dtime = tv.tv_sec + (double)tv.tv_usec / 1000000.0; if (!preQ.needsPrefetching && (stats->getBufAheadSec() <= RTP_BUF_PREFETCH) && ((state == OPEN) || (state == MUTED)) ) { dprintf_full("Rtp::getFrame: further PREFETCHING needed to fill empty buffers!\n"); preQ.needsPrefetching=true; stats->setStillToPrefetchSecs( stats->getStillToPrefetchSecs() + RTP_PREFETCH_SECS); flushBuffer(0,-1); //clean up all packets, since this will lead to a DataChannel Pause() } // PREFETCHING ########################################## if (preQ.needsPrefetching) { //initial or addtional prefetch is needed... bool done=false; oldState = state; setState(PREFETCHING); if (globalTimer) globalTimer->setPrefetching(true); fetch_time=0; do { //dprintf_full("...prefetching: left %f done %i needsPrefetch %i....state %i\n", // stats->getStillToPrefetchSecs(), done,preQ.needsPrefetching,state); msleep(10); gettimeofday(&tv,0); now_dtime = tv.tv_sec + (double)tv.tv_usec / 1000000.0; if (state == STREAMERR) { dprintf_err("Rtp::getFrame() STREAMERR occured during prefetching, returning NULL\n"); if (globalTimer) globalTimer->setPrefetching(false); return NULL; } if ((state != PREFETCHING) && (state != PAUSED)) { dprintf_full("Rtp::getFrame: continued PREFETCHING requested! left %f state %i\n", stats->getStillToPrefetchSecs(),state); //preQ.needsPrefetching=false; done=false; setState(PREFETCHING); // continue with prefetching... } if (firstFrame) { double fpt = stats->getFirstPacketTime(); double gstps = stats->getStillToPrefetchSecs(); if ( (fpt != 0) && //only take from real first frame (now_dtime - fpt >= gstps) ) { fetch_time = now_dtime - fpt; done=true; } } else { //intermediate prefetching //minor FIXME: pausing during intermediate Prefetching will shorten prefetching if (now_dtime - start_dtime >= stats->getStillToPrefetchSecs()) { fetch_time = now_dtime - start_dtime; done=true; } } } while ( !done && ((state == PREFETCHING) || (state == OPEN)|| (state == MUTED)|| (state == PAUSED)) ); if (state == PREFETCHING) setState(oldState); stats->setPrefetchedSecs(stats->getPrefetchedSecs() + fetch_time); //fine tune spent time stats->setStillToPrefetchSecs(0); stats->setBufAheadSec(((double)(stats->getHighestPacketTS()-stats->getFirstPacketTS()) / (double)es->getMediaTimeScale())); preQ.needsPrefetching=false; dprintf_full("Rtp::getFrame: prefetching of %2.3f secs (%2.3f real data recv secs)" " brought us %2.3f secs of %s! state %i, prefetched_secs: %f\n", now_dtime - start_dtime, fetch_time, stats->getBufAheadSec(), es->isVisualStream()?"Video":"Audio",state, stats->getPrefetchedSecs()); if (globalTimer) globalTimer->setPrefetching(false); } // MERGE FRAME FROM PACKETS ############################### do { p=popPreQ(); if(p==NULL) //this is the end.... my friend... return NULL; if (p==(Rtp::NetPacket_t *)-1) //FIXME: after unpause, the Q was empty! this will force PREFETCHING return this->getFrame(); dprintf_full("Rtp::getFrame popped rtp_seq %i, TS %i, last_frag %i size %i\n", p->rtp_seq,p->rtp_ts,p->last_frag,p->pl_size); if (IOFrameStat.seqno == -1) // init the rtp sequence IOFrameStat.seqno = p->rtp_seq; else IOFrameStat.seqno++; if (first_frag) { //first AU fragment if ( IOFrameStat.act_ts > (int)p->rtp_ts) { dprintf_full("DELETING left overs from previous frames\n"); old_ts = true; //left overs from previous frames } //else //IOFrameStat.act_ts = p->rtp_ts; first_frag = false; } if (old_ts || ((unsigned)IOFrameStat.seqno != p->rtp_seq)) { //old fragments or incomplete AU dprintf_err("Rtp::getFrame expected rtp_seq %i, I got %i\n",IOFrameStat.seqno, p->rtp_seq); //drop all other following fragments of incomplete AU //ATTN: this will read one more pkt from the NEXT frame and has to push it back! while ((IOFrameStat.act_ts > (int)p->rtp_ts) || (!old_ts && (IOFrameStat.act_ts == (int)p->rtp_ts)) ) { dprintf_full("Rtp::getFrame popped for dropping: rtp_seq %i, TS %i, last_frag %i\n", p->rtp_seq,p->rtp_ts,p->last_frag); delete p->payload; p->payload = NULL; delete p; p = NULL; p=popPreQ(); if(p==NULL) return NULL; //this is the end.... my friend... if (p==(Rtp::NetPacket_t *)-1) //FIXME: after unpause, the Q was empty! this will force PREFETCHING return this->getFrame(); } if ((unsigned)IOFrameStat.seqno != p->rtp_seq) { //pushback to preQ dprintf_err("LOSS: Not all fragments of TS %i where available\n",IOFrameStat.act_ts); addToPreQ(p,Q_TS,RTP_REINSERT); IOFrameStat.seqno = p->rtp_seq - 1; //restart seq_no from here if(buf) { delete[] buf; buf=NULL; } //try to get the next frame return this->getFrame(); } } dprintf_full("Rtp::getFrame CONT'd with popped rtp_seq %i, TS %i, last_frag %i\n", p->rtp_seq,p->rtp_ts,p->last_frag); IOFrameStat.act_ts = p->rtp_ts; lastFrag = p->last_frag; if(es->isAudioStream()) { //RFC2250 specific headers need to be removed //the header info is not utilized currently p->pl_size -= 4; buf=(u8*)realloc(buf, buf_siz + p->pl_size); memcpy(buf+buf_siz, p->payload + 4, p->pl_size); } else { buf=(u8*)realloc(buf,buf_siz + p->pl_size); memcpy(buf+buf_siz,p->payload,p->pl_size); } buf_siz+=p->pl_size; delete p->payload; p->payload=NULL; delete p; p=NULL; } while (lastFrag == 0); dprintf_full("Rtp::getFrame DONE TS %i\n", IOFrameStat.act_ts); //IF VIDEO ################################################3 if (es->isVisualStream()) if ((buf[3]==0xb0) && MP4Decoder::isValidDecoderConfig(buf)) { u8* tmp=buf+4; bool stop=false; // received a header! dprintf_full("Rtp::getFrame received header\n"); // some servers, like the ITECMP4Server send header+payload in one packet // catch this case while(!stop && tmp < (buf+buf_siz) && (tmp = (u8*)memchr(tmp, 0xb6, (buf+buf_siz)-tmp)) ) { if(tmp[-1] == 1 && tmp[-2] == 0 && tmp[-3] == 0) { stop=true; tmp-=3; } else tmp++; //avoid double findings } if (tmp) es->setDecoderConfig(buf,tmp-buf); else es->setDecoderConfig(buf,buf_siz); if(stop) { dprintf_full("Rtp::getFrame compound header %x %x %x %x (%i bytes) + frame (%li bytes) %x %x %x %x!\n" ,buf[0],buf[1],buf[2],buf[3], tmp-buf, buf_siz-(tmp-buf), tmp[0],tmp[1],tmp[2],tmp[3]); //fix everything up for final CompressedVideoFrame() creation buf_siz -= tmp-buf; u8* new_buf = new u8[buf_siz]; memcpy(new_buf,tmp,buf_siz); delete[] buf; buf = new_buf; } else { delete[] buf; buf=NULL; return this->getFrame(); //get the real frame } } else if ( !MP4Decoder::isValidVisualFrame(buf)) { dprintf_err("Rtp::getFrame LOSS: Not all frags of TS %i avail (broke header/missing first packet)\n", IOFrameStat.act_ts); delete[] buf; buf=NULL; //try to get the next frame return this->getFrame(); } //IF AUDIO ################################################3 if (es->isAudioStream()) if (MP4audioDecoder::isValidAudioFrame(buf)) { dprintf_full("Rtp::getFrame received audio frame header\n"); //Every audio frame consists of a 4 byte header + payload. These together comprise //the payload of the access unit. if(buf_siz == MPEG_AUDIO_HEADER_SIZE) { es->setDecoderConfig(buf,buf_siz); delete[] buf; buf=NULL; return this->getFrame(); } else { //FIXME: Decoder configuration may be required to be set for VBR audio for every frame!!! if (firstFrame) this->es->setDecoderConfig(buf,4); //"4" is for mpeg audio only ..... may be diff for aac } } else {// not valid audio dprintf_err("Rtp::getFrame LOSS: Not all audio frags of TS %i avail (broke header/missing first packet)\n", IOFrameStat.act_ts); delete[] buf; buf=NULL; //try to get the next frame return this->getFrame(); } //GENERAL FULL FRAME CREATION ####################### IOFrameStat.numProcessedFrames++; //fill the merged access unit au = new AU(); au->payload = buf; au->size = buf_siz; au->cts = au->dts = (u32) IOFrameStat.act_ts + (u32) ts_offset; Frame* f=NULL; if(es->isVisualStream()) f = new CompressedVideoFrame(Frame::NN_VOP, ((VideoESInfo*)es)->getWidth(), ((VideoESInfo*)es)->getHeight()); else if(es->isAudioStream()) f = new CompressedAudioFrame(Frame::NN_VOP); else f = new CompressedVideoFrame(Frame::NN_VOP, 0, 0); f->setAU(au); //FrameType is set here automatically f->setMediaTimeScale(es->getMediaTimeScale()); //used by GlobalTimer Adaptor dprintf_full("Rtp::getFrame got size %8i frameType %s TS %i presTime: %2.3f\n",f->getAU()->size, Frame::VOPTypeToChar(f->getType()),IOFrameStat.act_ts, (double)IOFrameStat.act_ts / es->getMediaTimeScale()); if (firstFrame) { // not a valid ESHeader as first packet? // do we have one from the RTSP? if(this->es->getEncodedDecoderConfig()==NULL) { dprintf_err("FATAL: no header found!! was: 0x%x%x%x%x\n", buf[0],buf[1],buf[2],buf[3]); setState(STREAMERR); delete[] buf; buf=NULL; delete f; f=NULL; delete au; au=NULL; close(true); //immediate return NULL; //this is the end... my friend... } firstFrame = false; } #ifdef _POSIX_PRIORITY_SCHEDULING if (sched_yield() != 0) { //this is necessary to give sendThread more realtime performance! perror("Rtp::writeFrame YIELD"); } #else // for windows pthread lib! #if (defined WIN32) && (!defined WINCE) if (sched_yield() != 0) { //this is necessary to give sendThread more realtime performance! dprintf_full("Rtp::writeFrame YIELD"); } #endif #endif return f; }

int Rtp::getNextPreQ_TS (   )  [protected]

Returns: the timestamp of the latest packet in the preQ (the one that would be popped next) or -1 if no packets where in queue Definition at line 2014 of file Rtp.cpp. { int ts; preQ.MUTEX_Q.lock(); if (preQ.Q_tail != NULL) ts = preQ.Q_tail->rtp_ts; else ts = -1; preQ.MUTEX_Q.release(); return ts; }

bool Rtp::open (   )  [virtual]

opens the IO connection. State is set to OPENING. Depending on the underlying QIODevice, a network connection or a file connection is established. When the connection is ready for use, State is OPEN and the run thread is started. Implements IO. Definition at line 268 of file Rtp.cpp. References ESInfo::getAvgBandwidth(), Statistics::getClientPreQMaxSize(), PortGenerator::getSockFromPort(), Statistics::setClientPreQMaxSize(), and IO::setState(). { dprintf_full("Rtp::open Rtp is %s, state is %i\n",(writeToNetwork) ? "write" : "read",state); if (state == OPEN) return true; setState(OPENING); /* setRoundRobinScheduling(1); */ currentFrameNumber=0; endFrameNumber=-0; IOFrameStat.numProcessedFrames=0; IOFrameStat.seqno = -1; IOFrameStat.act_ts = -1; //impossibly first CTS firstFrame=true; framesSeen = 0; if (remoteAddress && !session) { dprintf_full("Rtp::open init RTP channel ports %i <--> %i\n",localPort,remotePort); int p1, p2; p1=portGen.getSockFromPort(localPort); p2=portGen.getSockFromPort(localPort+1); dprintf_full("PortGenerator::dome\n"); fflush(stdout); session = ucl_rtp_init(remoteAddress, localPort, remotePort, TTL, 100, Rtp::RtpCallback, (uint8_t *) this, p1,p2); } dprintf_full("PortGenerator::\n"); fflush(stdout); if (session) { rtp_set_option(session, RTP_OPT_WEAK_VALIDATION, FALSE); rtp_set_option(session, RTP_OPT_PROMISC, TRUE); #ifndef WITHOUT_RTP_EXT if (!writeToNetwork) { // DataSink if (rtx) { dprintf_full("Rtp::open enabled to recv/send feedback!\n"); feedbackEnabled = true; //should we send feedback? enable it at UCL lib! if ((rtx->state == ACK) || (rtx->state == NACKACK)) rtp_set_option(session, RTCP_OPT_FB_ACK, TRUE); if ((rtx->state == NACK) || (rtx->state == NACKACK)) rtp_set_option(session, RTCP_OPT_FB_NACK, TRUE); } } else feedbackEnabled = true; //server will always accept extended feedback #endif if (rtx) { if (rtx->remotePort ==0) { dprintf_full("Rtp::open init RTP RTX channel port is ZERO! RTX disabled! still capable of recv/send feedback!\n"); } else { #ifndef WITHOUT_RTP_EXT dprintf_full("Rtp::open init RTP RTX channel ports %i <--> %i\n",rtx->localPort,rtx->remotePort); rtxEnabled = true; rtx->session = ucl_rtp_init(remoteAddress, rtx->localPort, rtx->remotePort, TTL, 100, Rtp::RtpCallback, (uint8_t *) this, portGen.getSockFromPort(rtx->localPort), portGen.getSockFromPort(rtx->localPort+1)); if (!rtx->session) { setState(STREAMERR); return false; } rtp_set_option(rtx->session, RTP_OPT_WEAK_VALIDATION, FALSE); rtp_set_option(rtx->session, RTP_OPT_PROMISC, TRUE); if (!writeToNetwork) { // DataSink //should we send rtx feedback? if ((rtx->state == ACK) || (rtx->state == NACKACK)) rtp_set_option(rtx->session, RTCP_OPT_FB_ACK, TRUE); if ((rtx->state == NACK) || (rtx->state == NACKACK)) rtp_set_option(rtx->session, RTCP_OPT_FB_NACK, TRUE); } #endif } }//if rtx setState(OPEN); firstFrame=true; // FIXME: on server-side this should be recv'd via RTSP/SDP! stats->setClientPreQMaxSize((RTP_CLIENT_PreQ_MAX_SECS+1) * (int) ((float)(es->getAvgBandwidth() / 8) * (1+RTP_BUF_FILL_FACT) ) ); if (writeToNetwork) //server has larger Q preQ.max_size = RTP_SERVER_PreQ_MAX; else preQ.max_size = stats->getClientPreQMaxSize(); preQ.size = preQ.num_elems = preQ.num_full_frames = 0; preQ.avg_bw = 0; // preQ.avg_bw = es->getAvgBandwidth(); preQ.highest_rtp_seq=0; preQ.highest_ts=0; dprintf_full("Rtp::open (ports %i:%i) is starting the according RTP thread\n",localPort,remotePort); this->start(); return true; } else { setState(STREAMERR); return false; } }

Rtp::NetPacket_t * Rtp::popPreQ (  bool  blocking = true  )  [protected]

block or get the first packet off the preQ this does neither free the packet, nor the packet payload! Parameters: blocking  if false, popPreQ might return with a NULL NetPacket Definition at line 2028 of file Rtp.cpp. References ESInfo::getMediaTimeScale(), and ESInfo::getVOPTimeIncrement(). Referenced by close(), and getFrame(). { NetPacket_t *p=NULL; int counter = 0; //dprintf_full("Rtp::popPreQ %s\n",blocking?"blocking":"non-blocking"); //FIXME: WHY !firstframe?? if (!firstFrame && blocking && (state != STREAMEOF)) if (blocking && (state != STREAMEOF)) preQ.MUTEX_Q_DATA_AVAIL.lock(); //wait for data //dprintf_full("Rtp::popPreQ data avail\n"); // preQ.MUTEX_Q.lock(); if ((state == FORCE_CLOSING) || (state == CLOSED)) { // preQ.MUTEX_Q.release(); if (writeToNetwork) preQ.MUTEX_Q_DONE.release(); dprintf_full("Rtp::popPreQ is quitting because of %s\n",(state==CLOSED?"CLOSED":"FORCE_CLOSING")); return NULL; } // preQ.MUTEX_Q.release(); preQ.MUTEX_Q.lock(); if ((state!=OPEN) && blocking && (preQ.Q == NULL)) { // if other thread is closing... dprintf_full("Rtp::popPreQ was blocking, but bailing out! empty Q and state %i!\n",state); preQ.MUTEX_Q.release(); return NULL; } if (preQ.Q == NULL) { dprintf_full("erroneously recv'd preQ.MUTEX_Q unlock.... no data after unpausing and state %i\n",state); preQ.MUTEX_Q.release(); return (Rtp::NetPacket_t *)-1; //FIXME: THIS IS A HACK!!!! } while (preQ.Q == NULL) { dprintf_full("Rtp::popPreQ has empty Q! (%ith try)!\n",counter); msleep(100); if (counter++ > 10) { preQ.MUTEX_Q.release(); dprintf_full("Rtp::popPreQ is quitting because of empty Q and state %i!\n",state); if (firstFrame) //this is needed for a special error case firstFrame=false; //during prefetching! return NULL; } } p=preQ.Q; preQ.Q = p->next; p->next = NULL; preQ.size -= p->pl_size; preQ.num_elems--; if ( (p->last_frag) && (p->resent_counter == 0) ) preQ.num_full_frames--; if (preQ.num_elems == 0) { // assert(preQ.num_full_frames == 0); preQ.Q_tail = NULL; preQ.avg_bw = 0; } else preQ.avg_bw = (int)(preQ.size/preQ.num_elems * ((double)es->getMediaTimeScale())/((double)es->getVOPTimeIncrement())); preQ.MUTEX_Q_FULL.release(); if (preQ.Q != NULL) { //still data available preQ.MUTEX_Q_DATA_AVAIL.release(); } preQ.MUTEX_Q.release(); return p; }

void Rtp::preQupdate (   )  [protected]

scans the preQ for missing packets and requests their retransmission since in the client, not frame type is known, EVERY missing packet is reqeusted... Definition at line 1671 of file Rtp.cpp. References Statistics::getHighestPacketTS(). { Rtp::NetPacket_t *p=NULL; int act_seq = -1; int prev_seq = -1; int ret; if (!rtxEnabled) { dprintf_full("Rtp::preQupdate: no rtxEnabled... ignoring\n"); return; } dprintf_full("Rtp::preQupdate\n"); preQ.MUTEX_Q.lock(); p = preQ.Q; while (p != NULL) { act_seq=p->rtp_seq; // dprintf_full("Rtp::preQupdate checks on %i ts %i (prev %i)\n",act_seq,p->rtp_ts,prev_seq); if (prev_seq != -1) { while (++prev_seq < act_seq) { //missing packet dprintf_full("Rtp::preQupdate: requesting %i (remaining: %i, final will be %i), sess %p ssrc %x\n", prev_seq, act_seq-1-prev_seq, act_seq-1, session, sender_ssrc); ret=rtp_send_explicit_nack(session, sender_ssrc, prev_seq, stats->getHighestPacketTS(), NULL); assert(act_seq > prev_seq); //assert(act_seq-1 - prev_seq < 30 && "YOUR SYSTEM IS TOO SLOW! LOST TOO MANY PACKETS IN A ROW!!!"); if (ret == -1) { dprintf_err("Rtp::preQupdate ERROR! rtp session wrong!!!!\n"); break; } } } prev_seq = act_seq; p = p->next; } preQ.MUTEX_Q.release(); }

void Rtp::run (   )  [virtual]

this thread works on the read buffer, using the estimated avail. bandwidth for send out rate Reimplemented from IO. Definition at line 2096 of file Rtp.cpp. References VThread::setRoundRobinScheduling(). { dprintf_full("Rtp::run (ports %i:%i) is starting the according RTP thread\n",localPort,remotePort); #ifndef QT_THREAD_SUPPORT int ret = setRoundRobinScheduling(2); if (ret == 0) { dprintf_full("Rtp::sendThread switched to RT-RR SCHEDULING!\n"); } else { dprintf_full("Rtp::sendThread couldnt change to RT-RR SCHEDULING! (got root?) : err %i\n",ret); } #endif if (writeToNetwork) //Sender sendThread(); else readThread(); }

void Rtp::sendQupdate (  long  streamout_sec  )  [protected]

scans the SendQ for already ack'd or out-dated frames and releases them. Parameters: streamout_sec  determines the actual time, or if set to -1, every frame in the SendQ will be dropped Definition at line 1614 of file Rtp.cpp. References ESInfo::getMediaTimeScale(), and Statistics::getPrefetchedSecs(). Referenced by close(). { Rtp::NetPacket_t *p=NULL, *pprev=NULL; int slot; long ssec_ticks, threshold; ssec_ticks = es->getMediaTimeScale() * streamout_sec; threshold = (long)(ssec_ticks - ((u64)ceil(stats->getPrefetchedSecs()) * es->getMediaTimeScale())); if ((streamout_sec >= 0) && (threshold < 0)) { //not "flushAll" and initial prefetching dprintf_full("Rtp::sendQupdate(ssec %li): ignoring since initial prefetching (threshold TS %li)\n", streamout_sec,threshold); return; } dprintf_full("Rtp::sendQupdate(ssec %li): drop all older than TS %li\n",streamout_sec, threshold); sendQ.MUTEX_Q.lock(); for (slot=0; slot<RTP_SENDQ_PRIME;slot++) { p = sendQ.Q[slot]; pprev = NULL; while (p != NULL) { if ( (streamout_sec == -1) || //-1 == drop all (p->rtp_ts + (u64)ceil(stats->getPrefetchedSecs()) * es->getMediaTimeScale() < (unsigned)ssec_ticks) || (p->acked) ) { //dprintf_full("NOW TS: %li Frame seq %i ts %i:%i is outdated or acked... now dropped\n", // streamout_sec*es->getMediaTimeScale(),p->rtp_seq, p->rtp_ts,p->frag_no); sendQ.size -= p->pl_size; sendQ.num_elems--; if (pprev) pprev->next = p->next; else sendQ.Q[slot]=p->next; assert(p->payload != NULL); delete p->payload; p->payload=NULL; delete p;p=NULL; if (pprev) p = pprev; //to continue while else p = sendQ.Q[slot]; } if (sendQ.Q[slot] == NULL) break; pprev = p; p = p->next; } } sendQ.MUTEX_Q.release(); }

bool Rtp::setEndFrameNumber (  u32  frameNumber  )  [virtual]

sets the last frame that should be sent. Allows to specify in combination with setToFrameNumber a range of frames that should be sent. Set Parameters: stopNumber  to 0, to specify the last frame. Returns: true on success Reimplemented from IO. Definition at line 448 of file Rtp.cpp. References flushBuffer(), and ESInfo::getVOPTimeIncrement(). { long incr = es->getVOPTimeIncrement(); if (endFrameNumber == 0) flushBuffer(frameNumber * incr, -1); else flushBuffer(frameNumber * incr, endFrameNumber * incr); endFrameNumber=frameNumber; return true; }

void Rtp::setRtxInfo (  const rtx_info *  rtx  )  [virtual]

sets a shallow copy of Parameters: rtx  at the ESInfo object Reimplemented from IO. Definition at line 2853 of file Rtp.cpp. { assert(rt); dprintf_full("Rtp::setRtxInfo \n"); if(rtx) { delete rtx; } rtx= new rtx_info(rt); };

bool Rtp::setToFrameNumber (  u32  frameNumber  )  [virtual]

repositions the IO class to the given frame. Will return false in the following cases: an illegal frame number (too large) was specified the stream is not seekable, because the underlying device is a network device and the requested frame is already out of range. Seeking doesn't work on IO classes opened for writing Reimplemented from IO. Definition at line 461 of file Rtp.cpp. References flushBuffer(). { flushBuffer(0, -1); currentFrameNumber=frameNumber; return true; }

void Rtp::ucl_update (  u32  ts, u32  timeout )  [protected]

calls UCL lib for RTP,RTCP updates and callback functions (recv data) Parameters: ts  is the current timestamp timeout:  if zero, non-blocking, else in msecs Definition at line 1077 of file Rtp.cpp. { struct timeval tv; dprintf_full("Rtp::ucl_update TS %i\n",ts); if (session) { rtp_update(session); rtp_send_ctrl(session, ts, NULL, RTCP_NORMAL); /* Receive control and data packets */ tv.tv_sec = 0; tv.tv_usec = timeout*1000; if (rtxEnabled) tv.tv_usec = tv.tv_usec >> 1; //wait half of the time on rtp assert(session); rtp_recv(session, &tv, ts); if (rtxEnabled) { // dprintf_full("Rtp::ucl_update on RTX at TS %i\n",ts); rtp_send_ctrl(rtx->session, ts, NULL, RTCP_NORMAL); /* eventually receive NACK packets again */ tv.tv_sec = 0; tv.tv_usec = timeout*1000 >> 1; //wait other half of the time on rtcp assert(rtx->session); rtp_recv(rtx->session, &tv, ts); /* do maintenance */ rtp_update(rtx->session); } bool ret; int rounds=0; do { tv.tv_sec = 0; tv.tv_usec = 1; //wait nearly no time ret=rtp_recv(session, &tv, ts); //try to get as much data as possible if (rtxEnabled) { tv.tv_sec = 0; tv.tv_usec = 1; //wait nearly no time ret=rtp_recv(rtx->session, &tv, ts); } rounds++; } while(session && ret && (rounds < 10)); //continue as long as data or rtx avail, or 10 pks where read in a row } }

int Rtp::writeFrame (  Frame *  frm, ESInfo *  out_es = NULL )  [virtual]

just adds a frame to the send buffer. sending per se is handled in the run thread. If the send buffer is full, writeFrame will block. Parameters: frm  Returns: the number of packets delivered. Returns 0 on error Implements IO. Definition at line 552 of file Rtp.cpp. References PacketizationLayer::createSLPacketList(), Frame::getAU(), ESInfo::getHeaders(), Frame::getType(), ESInfo::getVOPTimeIncrement(), and insertToPreQ(). { bool result = true; SLPacketList slpl; AU au; u8* newPayload=NULL; bool last = false; int counter = 0; if (!writeToNetwork || state != OPEN || !pLayer || !frm) return 0; dprintf_full("Rtp::writeFrame CTS %i prio %i size %i\n",frm->getAU()->cts, frm->getAU()->prio, frm->getAU()->size); if (endFrameNumber>0 && frm->getAU()->cts / es->getVOPTimeIncrement() > endFrameNumber) { //this comes from unflushed DC senqueue, and is out of range, so drop it! dprintf_full("Rtp::writeFrame nr %i TS %i exceeds endFrameNumber %i, ignoring!\n",frm->getAU()->cts / es->getVOPTimeIncrement(),frm->getAU()->cts, endFrameNumber ); return 0; } //HEADER DATA if ( (!firstFrame && resendFrameHeader ) || (firstFrame && !MP4Decoder::isValidDecoderConfig(frm->getAU()->payload)) ) { //HEADER already in first frame resendFrameHeader=false; firstFrame=false; //send extra header! u8* esHeaderBuffer=NULL; u32 headerSize=es->getHeaders(&esHeaderBuffer); if(headerSize>0) { newPayload=new u8[headerSize + frm->getAU()->size]; memcpy(newPayload, esHeaderBuffer, headerSize); au.payload=newPayload; au.size=headerSize; au.cts=frm->getAU()->cts; au.dts=frm->getAU()->dts; au.duration=0; slpl=pLayer->createSLPacketList(&au); if(!slpl.empty()) { SLPacketList::iterator li = slpl.begin(); last = false; counter = 0; dprintf_full("Rtp::writeFrame: HEADER (size %i) first 4 bytes of first Packet, CTS %u: %x %x %x %x\r\n", headerSize, frm->getAU()->cts, (*li)->getPayload()[0],(*li)->getPayload()[1], (*li)->getPayload()[2],(*li)->getPayload()[3]); while(!slpl.empty()) { if(slpl.size()==1) { last=true; } li = slpl.begin(); result &= insertToPreQ((*li)->getPayload(), (*li)->getPayloadSize(), frm->getType(), au.size, IO_NETWORK_HIGHEST_PRIORITY, frm->getAU()->dts, counter, last, 0,Rtp::Q_TS); (*li)->unsetPayload(); //payload will be freed when ACKd delete *li; // here, there is no payload to free any more... (*li)=NULL; slpl.pop_front(); counter++; } } } if(esHeaderBuffer) { delete[] esHeaderBuffer; esHeaderBuffer=NULL; } } //FRAME DATA slpl = pLayer->createSLPacketList(frm->getAU()); firstFrame=false; if (slpl.empty()) { dprintf_full("Rtp::writeFrame() SLPacketList is empty! AU: size = %u, cts = %u\n", frm->getAU()->size, frm->getAU()->cts); return 1; //fake success, since the SLPacket is buffered and not yet full MTU reached... } SLPacketList::iterator li = slpl.begin(); dprintf_full("Rtp::writeFrame: FRAME first 4 bytes of Frame, CTS %u: %x %x %x %x\r\n", frm->getAU()->cts, frm->getAU()->payload[0], frm->getAU()->payload[1], frm->getAU()->payload[2],frm->getAU()->payload[3]); last=false; //counter stays to old value (might be with header) while(!slpl.empty()) { if(slpl.size()==1) { last=true; } li = slpl.begin(); result &= insertToPreQ((*li)->getPayload(), (*li)->getPayloadSize(), frm->getType(), frm->getAU()->size, frm->getAU()->prio, frm->getAU()->dts, counter, last, 0, Rtp::Q_TS); (*li)->unsetPayload(); //payload will be freed when ACKd delete *li; // here, there is no payload to free any more... (*li)=NULL; slpl.pop_front(); counter++; } IOFrameStat.numProcessedFrames++; #ifdef _POSIX_PRIORITY_SCHEDULING if (sched_yield() != 0) { //this is necessary to give sendThread more realtime performance! perror("Rtp::writeFrame YIELD"); } #else // for windows pthread lib! #if (defined WIN32) && (!defined WINCE) if (sched_yield() != 0) { //this is necessary to give sendThread more realtime performance! dprintf_full("Rtp::writeFrame YIELD"); } #endif #endif return (int)result; }

---

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

• Rtp.hpp
• Rtp.cpp

© ViTooKi 2003 :: [Lite version] Created with Doxygen