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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Rtp.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       Rtp.hpp                                                       *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef _MK_RTP_HPP_
#define _MK_RTP_HPP_
#ifdef WIN32
#pragma warning(disable:4786)
#endif

#include "VMutex.hpp"

#include "IO.hpp"
#include "ESInfo.hpp"
#include "adaptors/GlobalTimer.hpp"
#include "net/PortGenerator.hpp"
#ifdef WINCE
#include "3rdparty/commonucl/rtp.h" // UCL library
#else
#include "commonucl/rtp.h" // UCL library
#endif

class Frame;
class PacketizationLayer;
class SyncLayer;
class TerminalCapabilities;
class Statistics;

extern PortGenerator portGen;

/* how many secs worth of data should be prefetched on startup or if buffers dry out? 
 * Type: SECONDS */
#ifdef LARGE_PREFETCH
#define RTP_PREFETCH_SECS 20
#else
#define RTP_PREFETCH_SECS 8
#endif

/* this is for gdb'd client or QuickTime to come up receiving!
 * Type: SECONDS */
#define RTP_SENDER_PRESLEEP 1


/* General preQ Buffer Settings */
/* preQ is set to max 60 secs of fitting stream_BW of chosen video (eg. 60*500KBit/sec
 * Type: SECONDS */
#define RTP_CLIENT_PreQ_MAX_SECS  60

/* if client buffer has less than eg. 5 secs of video we force higher adaptation to fill buf
 * Type: SECONDS */
#define RTP_BUF_LOWWATER  5

/* if client buffer has more than eg. 30 secs of video we allow lower adaptation and drain buf
 * Type: SECONDS */
#define RTP_BUF_HIGHWATER  25


class Rtp:public IO {
public:
        
  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);
  virtual ~ Rtp();

        Statistics *getStatistics() { return stats; };

        void setESInfo(ESInfo * new_es);
        ESInfo* getESInfo() { return es;};
  Frame *getFrame();
  
  int writeFrame(Frame * frm, ESInfo *out_es=NULL);

        void resendHeader() { resendFrameHeader=true;} ;


  void run();

  bool open();

        State play(double prefetchTime);

        State pause();

        State mute();

  bool close(bool immediate=false);
  
  int getLocalPort() const { return localPort; };

  int getBufferFillLevelInPercent() const { return (int)(preQ.size/((float)preQ.max_size/100.0)); };
  int getBufferFillLevel() const { return getBufferFillLevelInPercent(); };

  int getBufferFillLevelInBytes() const { return preQ.size; };

        int flushBuffer(long from_ts = 0, long to_ts = -1);

        /* is this Rtp object for reading from network? (eg. client side) */
        bool isInput() {return !writeToNetwork; };
        /* is this Rtp object for writing to network? (eg. server side) */
        bool isOutput() {return writeToNetwork; };

  bool destroy() { return true; } 
  const char *getURL() const { return url; };
  char *getSSRC();

        void setRtxInfo(const rtx_info* rtx);

        const rtx_info* getRtxInfo() const { return rtx;};

        /* flushes the buffer before the given @param frameNumber
         * be aware that this currentFrameNumber will be reset if the input is changed with setESInfo()
         * and will be increased with every streamed out frame later on
         */
        bool setToFrameNumber(u32 frameNumber);

        /* flushes the buffer after the given @param frameNumber
         * be aware that this endFrameNumber will be reset if the input is changed with setESInfo()
         */
        bool setEndFrameNumber(u32 frameNumber);


/*******************************************************/
protected:

        struct NetPacket_t; //fwd decl

  static void RtpCallback(struct rtp *session, rtp_event * e);
  static void fb_print(struct rtp *session, uint32_t ssrc, rtcp_fb *fb);
  static void fb_handle(struct rtp *session, uint32_t ssrc, rtcp_fb *fb);
        static void rtp_data_handle(struct rtp *session, uint32_t ssrc, rtp_packet *packet);

        typedef enum {Q_HEAD, Q_TAIL, Q_TS, Q_SEQ} QOrder;
  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);

        /* used to ignore preQ fill level and for pushback */
#define RTP_REINSERT true

  bool reinsertToPreQ(NetPacket_t *p, uint rtp_seq);

        bool addToPreQ(NetPacket_t *p, QOrder qo, bool pushback=false);

        NetPacket_t *popPreQ(bool blocking=true);


        void calcAdaptPreQValues(int net_bw);


        void markFullFramePartially(bool dropped, bool sent, u32 ts);

        void adaptPreQ(int net_bw);

        int getNextPreQ_TS();

        // SendQ related methods
  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);

        void preQupdate();

        /* @param NetPacket_t takes a NetPacket and sends it either as new data or as RTX 
         * ATTN: it sets the p->rtp_seq and, if applicable, p->rtx_rtp_seq and timestamps
         * @returns the number of sent bytes or -1 on error */
        int doSend(NetPacket_t *p);

        void sendThread();
        void readThread();

  void ucl_update(u32 ts, u32 timeout);


        /************************************************
  * Variables *************************************/

  typedef struct NetPacket_t {
    uint32_t    rtp_seq;         // rtp sequence number

                uint16_t    rtx_rtp_seq;     // seqNo of this resent packet on the RTX channel
                int         resent_counter;  // how often was this pkt resent?
                bool        acked;           // already acked?

    u32         rtp_ts;          // rtp composition timestamp
                double      sent_dtime;      // time passed since thread_start_dtime
                double      resent_dtime;

    Frame::FrameType   vop_type;        // I,P,B, NN... this packet might be just a fragment!
                u32         vop_size;        // NOT the actual packet size, but the full frame size!
                int         prio;            // adaptation priority   0..high (definitely keep) (eg. I,P)

                bool        partially_sent;    // an arbitrary fragment of this TS is already on the net!
                bool        partially_dropped; // an arbitrary fragment of this TS is already dropped!
                bool        drop_me;         // set if this packet was selected for adaptation

    u32         frag_no;         // 0..first packet, 1..n following fragments
                                             // on clientside: rtp_seq, which also gives a monotonic order 
                                 //                within TS!
    bool        last_frag;       // flag, if this is the last fragment of frame
    u8          *payload;
    u32         pl_size;         // payload bytes
    NetPacket_t *next;
  } NetPacket_t;

        struct CompareNetPackets
        {
                bool operator()(NetPacket_t*& np1,
                                                                                NetPacket_t*& np2) const
                {
      return (np1->prio < np2->prio);
                }
        };
  
  struct PreQ_t {
    NetPacket_t *Q; /* will be taken and sent. 
                            will then go into sendQ with the new rtp_seq */
    NetPacket_t *Q_tail; /* points to the last elem */

    VMutex MUTEX_Q;
    VMutex MUTEX_Q_DATA_AVAIL;
    VMutex MUTEX_Q_FULL;
    VMutex MUTEX_Q_DONE;
                bool isDirty;
                bool needsPrefetching;

                unsigned long max_size;
    unsigned long size;
    uint num_elems;
                uint num_full_frames;
    uint avg_bw;   // avg BW/sec of frames in PreQ, not of whole video!

                uint32_t highest_rtp_seq;
                uint32_t highest_ts;
  } preQ;


#define RTP_SENDQ_PRIME 37
        struct SendQ_t {
                NetPacket_t *Q[RTP_SENDQ_PRIME];
                long size;
                uint num_elems;
                uint avg_bw;  // avg BW/sec of frames in SendQ, not of whole video!
                VMutex MUTEX_Q;
        } sendQ;


        Statistics *stats;
  struct rtp *session;
        uint32_t sender_ssrc;
  int remotePort;
  int localPort;
  char *remoteAddress;
#ifndef WIN32
  static const int TTL = 16;
  static const int MAX_PAYLOAD_SIZE = 65000;
  static const int RTP_PAYLOAD_TYPE = 96;
#endif
  bool writeToNetwork;
  bool firstFrame;

        //global state used by getFrame
        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;   //if the server doesnt start at TS=0, but later, fix the offset....

        int64_t  first_rtx_rtp_seq;
  uint16_t last_rtx_rtp_seq;
        int interarrival_time;       // msecs
        int net_bw_before_superdrain; // when super-draining is necessary, we keep the old (good) net_bw
        int real_bw;       // stream_bw, adjusted by 1 second +- DRAIN/FILL fact

  bool threadWasPaused;
        bool allowVopTimeDetection;
};

#endif

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