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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Statistics.hpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       Statistics.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_STATISTICS_HPP
#define MK_STATISTICS_HPP

#include "global.hpp"
#include "ESInfo.hpp"

class Statistics {

#define RTP_AVG_RTT_ALPHA 0.75

#define RTP_STAT_SECS 30

public:

  Statistics(ESInfo *esi, bool channelIsWriter);

  virtual ~Statistics();        

        void setESInfo(ESInfo *new_es);

  //REALLY PUBLIC METHODS FOR GUI AND OTHER STAT READERS

  u32 getStreamoutSec() { return streamout_sec; };

  double getStreamoutFloatSec() { return streamout_float_sec; };

  double getPlayoutSec() { return playout_sec; };

  long getBWfromStreamoutSec(u32 sec);

  long getBWfromPlayoutSec(u32 sec);

  u32 getNumStreamoutSecs();

  double getBufferFillLevelInSecs() const { return buf_ahead_sec; };


  //DIRECT ACCESS TO STATISTICS! ONLY USE THEM IF YOU KNOW WHAT YOU DO!

  void setFirstPacketTS(u32 ts) { first_packet_ts = ts; };
  u32 getFirstPacketTS() { return first_packet_ts; };

  void setHighestPacketTS(u32 ts) { highest_packet_ts = ts; };
  u32 getHighestPacketTS() { return highest_packet_ts; };

  void setStreamoutFullSec(u32 sec) { streamout_sec = sec; };
  u32 getStreamoutFullSec() { return streamout_sec; };

  void setStreamoutFloatSec(double sec) { streamout_float_sec = sec; };
  //moved up to public methods
  //    double getStreamoutFloatSec() { return streamout_float_sec; };

  void setPlayoutSec(double sec) { playout_sec = sec; };
  //moved up to public methods
  // double getPlayoutSec() { return playout_sec; };

  void setBufAheadSec(double sec) { buf_ahead_sec = sec; };
  double getBufAheadSec() { return buf_ahead_sec; };

  void setClientPreQMaxSize(u32 size) { client_preQ_max_size = size; };
  u32 getClientPreQMaxSize() { return client_preQ_max_size; };

  void setStillToPrefetchSecs(double secs){ stillToPrefetchSecs = secs; };
  double getStillToPrefetchSecs() { return stillToPrefetchSecs; };

  void setPrefetchedSecs(double secs){ prefetched_secs = secs; };
  double getPrefetchedSecs() { return prefetched_secs; };

  void setFirstPacketTime(double time) { first_packet_dtime = time; };
  double getFirstPacketTime() { return first_packet_dtime; };

  void setLastPacketTime(double time) { last_packet_dtime = time; };
  double getLastPacketTime() { return last_packet_dtime; };

  /* will be averaged by an alpha */
  int setAvgRTT(int rtt);
  int getAvgRTT() { return avg_rtt; };

  /* will be averaged by an alpha */
  int setAvgInterarrivalTime(int msecs);
  int getAvgInterarrivalTime() { return avg_interarrival_time; };

  /* estimated bandwidth to stream one second in best quality, quasi-static
   * (normally, a little more than avg bw) */
  void setStreamBW(int bw) { stream_bw = bw; };
  int getStreamBW() { return stream_bw; };

        /* the start-streamBW of the very first stream (not affected by switching) */
  void setBaseStreamBW(int bw) { base_stream_bw = bw; };
  int getBaseStreamBW() { return base_stream_bw; };

  void setAdaptRate(int rate) { adapt_rate = rate; };
  int getAdaptRate() { return adapt_rate; };

  void setAdaptSecs(double secs) { adapt_secs = secs; };
  double getAdaptSecs() { return adapt_secs; };


#define IN_PLAYOUT_ARR (sec) {if (sec < MAX(0,(int)floor((double)getHighestPacketTS() / es->getMediaTimeScale() - RTP_STAT_SECS))) return false;}
#define IN_STREAMOUT_ARR (sec) {if (sec < MAX(0,(int)getStreamoutFullSec() - RTP_STAT_SECS)) return false;}
#define RET_OK {return true;}

  //METHODS FOR STAT ARRAYS
  //PLAYOUT STATS

  bool checkForNewPlayoutSec(int this_frame_sec, int highest_ts_sec);

  /* writePlayoutStats will be called if a new playoutSec occurs to the Adaptors (ergo real viewing) */
  void writePlayoutSecStats(int this_frame_sec);

        void setVOPTimeIncrement(int incr) { es->setVOPTimeIncrement(incr); };

        /* returns the original framerate from the ESInfo */
        float getOriginalFPS() { return (double)es->getMediaTimeScale() / (double)es->getVOPTimeIncrement(); };
        
  /* increases the FPS, which arrived thru network/file for the given sec (used by IO class) 
   * they might not be displayed because of the ESSychronizer adaptor or decoding errors
   */
  bool incPlayoutSecNetFPS(int sec) { playsec_stat[sec % RTP_STAT_SECS].net_fps++; RET_OK };
  bool decPlayoutSecNetFPS(int sec) { playsec_stat[sec % RTP_STAT_SECS].net_fps--; RET_OK };
  int  getPlayoutSecNetFPS(int sec) { return playsec_stat[sec % RTP_STAT_SECS].net_fps; };

  /* increases the FPS which was _really_ displayed 
   * after ESSync adaptor and after decoding errors (eg. missing I-VOPs make B-VOPs undecodable */
  bool incPlayoutSecFPS(int sec) { playsec_stat[sec % RTP_STAT_SECS].fps++; RET_OK };
  bool decPlayoutSecFPS(int sec) { playsec_stat[sec % RTP_STAT_SECS].fps--; RET_OK };
  int  getPlayoutSecFPS(int sec) { return playsec_stat[sec % RTP_STAT_SECS].fps; };

  bool incPlayoutSecIFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].iframes++; RET_OK };
  bool decPlayoutSecIFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].iframes--; RET_OK };
  int  getPlayoutSecIFrame(int sec) { return playsec_stat[sec % RTP_STAT_SECS].iframes; };

  bool incPlayoutSecPFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].pframes++; RET_OK };
  bool decPlayoutSecPFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].pframes--; RET_OK };
  int  getPlayoutSecPFrame(int sec) { return playsec_stat[sec % RTP_STAT_SECS].pframes; };

  bool incPlayoutSecBFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].bframes++; RET_OK };
  bool decPlayoutSecBFrame(int sec) { playsec_stat[sec % RTP_STAT_SECS].bframes--; RET_OK };
  int  getPlayoutSecBFrame(int sec) { return playsec_stat[sec % RTP_STAT_SECS].bframes; };

  bool incPlayoutSecPSNR(int sec, double psnr);
  double getPlayoutSecPSNR(int sec);

  bool incPlayoutSecDataPkts(int sec) { playsec_stat[sec % RTP_STAT_SECS].num_data_pkts++; RET_OK };
  bool decPlayoutSecDataPkts(int sec) { playsec_stat[sec % RTP_STAT_SECS].num_data_pkts--; RET_OK };
  int  getPlayoutSecDataPkts(int sec) { return playsec_stat[sec % RTP_STAT_SECS].num_data_pkts; };

  bool incPlayoutSecRtxPkts(int sec) { playsec_stat[sec % RTP_STAT_SECS].num_rtx_pkts++; RET_OK };
  int  getPlayoutSecRtxPkts(int sec) { return playsec_stat[sec  % RTP_STAT_SECS].num_rtx_pkts; };

  bool incPlayoutSecDataBW(int sec, int bw) { playsec_stat[sec % RTP_STAT_SECS].data_bw += bw; RET_OK };
  bool decPlayoutSecDataBW(int sec, int bw) { playsec_stat[sec % RTP_STAT_SECS].data_bw -= bw; RET_OK };
  int  getPlayoutSecDataBW(int sec) { return playsec_stat[sec % RTP_STAT_SECS].data_bw; };

  bool incPlayoutSecRtxBW(int sec, int bw) { playsec_stat[sec % RTP_STAT_SECS].rtx_bw += bw; RET_OK };
  int  getPlayoutSecRtxBW(int sec) { return playsec_stat[sec % RTP_STAT_SECS].rtx_bw; };

  bool incPlayoutSecNackedBW(int sec, int bw) { playsec_stat[sec % RTP_STAT_SECS].nacked_bw += bw; RET_OK };
  int  getPlayoutSecNackedBW(int sec) { return playsec_stat[sec % RTP_STAT_SECS].nacked_bw; };


  //STREAMOUT STATS
  bool checkForNewStreamoutSec(double now_dtime);
  /* writeClientStats will be called if a new StreamoutSec occurs to RTP */
  void writeStreamoutSecClientStats(long preQsize);
  /* writeClientStats will be called if a new StreamoutSec occurs to RTP, 
   * after all Adapt adjustments happened */
  void writeStreamoutSecServerStats();

        /* @returns the percentage of lost packets */
        float getStreamoutSecLossPercent(int sec);

  bool incStreamoutSecDataPkts(int sec) { streamsec_stat[sec % RTP_STAT_SECS].num_data_pkts++; RET_OK };
  bool decStreamoutSecDataPkts(int sec) { streamsec_stat[sec % RTP_STAT_SECS].num_data_pkts--; RET_OK };
  int  getStreamoutSecDataPkts(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].num_data_pkts; };

  bool incStreamoutSecRtxPkts(int sec) { streamsec_stat[sec % RTP_STAT_SECS].num_rtx_pkts++; RET_OK };
  int  getStreamoutSecRtxPkts(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].num_rtx_pkts; };

  bool incStreamoutSecDataBW(int sec, int bw) { streamsec_stat[sec % RTP_STAT_SECS].data_bw += bw; RET_OK };
  bool decStreamoutSecDataBW(int sec, int bw) { streamsec_stat[sec % RTP_STAT_SECS].data_bw -= bw; RET_OK };
  int  getStreamoutSecDataBW(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].data_bw; };

  bool incStreamoutSecRtxBW(int sec, int bw) { streamsec_stat[sec % RTP_STAT_SECS].rtx_bw += bw; RET_OK };
  int  getStreamoutSecRtxBW(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].rtx_bw; };

  bool incStreamoutSecNackedBW(int sec, int bw) { streamsec_stat[sec % RTP_STAT_SECS].nacked_bw += bw; RET_OK };
  int  getStreamoutSecNackedBW(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].nacked_bw; };

  bool setStreamoutSecNetBW(int sec, int bw) { streamsec_stat[sec % RTP_STAT_SECS].net_bw = bw; RET_OK };
  int  getStreamoutSecNetBW(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].net_bw; };

  bool setStreamoutSecClientBufFill(int sec, int size) { streamsec_stat[sec % RTP_STAT_SECS].client_buf_fill = size; RET_OK };
  bool incStreamoutSecClientBufFill(int sec, int size) { streamsec_stat[sec % RTP_STAT_SECS].client_buf_fill += size; RET_OK };
  int getStreamoutSecClientBufFill(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].client_buf_fill; };

  bool setStreamoutSecPlayoutSec(int sec, double plSec) { streamsec_stat[sec % RTP_STAT_SECS].playout_sec = plSec; RET_OK };
  double getStreamoutSecPlayoutSec(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].playout_sec; };

  bool setStreamoutSecBufAhead(int sec, double time) { streamsec_stat[sec % RTP_STAT_SECS].buf_ahead = time; RET_OK };
  double getStreamoutSecBufAhead(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].buf_ahead; };

  bool incStreamoutSecNumBKeepChecks(int sec) { streamsec_stat[sec % RTP_STAT_SECS].num_bkeep_checks++; RET_OK };
  int getStreamoutSecNumBKeepChecks(int sec) { return streamsec_stat[sec % RTP_STAT_SECS].num_bkeep_checks; };

private:

  /* stats for one playout second
   * all values are directly mapped to the according playout sec
   * eg. bw is the exact bytes count for the playout sec, this might be far away from
   *  avg. BW and streamout rate
   * fps and sum_psnr are set from within the according adaptors (ESSynchronizer and PSNR)
   */
  typedef struct {
    int num_data_pkts;  // overall num sent/recv'd
    int num_rtx_pkts;   // subset of rtx sent/recv'd
    int data_bw;        // how much real data was sent/recv'd?
                        // (including rtp packet header sizes)
    int rtx_bw;         // how many bytes were retransmissions?
    int net_fps;        // available full frames (rate) from network
    int fps;            // available full frames (rate) at PlayoutTime
                        // (according to their TS)
                int iframes;            // number of I frames within this playout second
                int pframes;              // number of P frames within this playout second
                int bframes;              // number of B frames within this playout second
    double sum_psnr;    // the sum psnr for this playout second, has to
                        // be DIV num_psnr!
    double num_psnr;    // the num psnr for this playout second
    
    //SERVER ONLY:
    int nacked_bw;      // how many bytes lost? (client doesn't know
                        // how many bytes were missing...)
                int stream_bw;      // the streamBW of the current stream
                bool stream_switched;  // indicates if in this sec, a new ES was set ( == stream switched)
  } OnePlayoutSecStat;
  
  /* stats for one streamout second
   *all values are measured in this streamout sec and stored to that statistics
   * eg. bw is the exact bytes count for this streamout sec and should equal the 
   * requested streamout rate
   */
  typedef struct {
    int num_data_pkts;  // overall num sent/recv'd
    int num_rtx_pkts;   // subset of rtx sent/recv'd    
    int data_bw;        // how much real data was sent/recv'd?
                        // (including rtp packet header sizes)
    int rtx_bw;         // how many bytes were retransmissions?
    int net_bw;         // how many bytes _should_ be streamed?
    double playout_sec; // where is actual playout
    u32 client_buf_fill;// estimation on bytes in client buffer
    double buf_ahead;   // estimated, how far is the buffer ahead to playout sec
    
    //SERVER ONLY:
    int nacked_bw;      // how many bytes lost? (client doesn't know
                        // how many bytes were missing...)
    int num_bkeep_checks; // num of tried RTCP bookkeeping
                int stream_bw;      // the streamBW of the current stream
                bool stream_switched;  // indicates if in this sec, a new ES was set ( == stream switched)
  } OneStreamoutSecStat;
  
  //GENERIC STATISTICS
  double first_packet_dtime;
  double last_packet_dtime;
  u32 first_packet_ts;
  u32 highest_packet_ts;
  double playout_sec;          // estimated client playout sec
  OnePlayoutSecStat playsec_stat[RTP_STAT_SECS]; //tracks the buffer stats
                                                 // of the last few secs
  
  //NETWORK RELATED STUFF
  u32 streamout_sec;           // relative to thread_start_dtime
  double streamout_float_sec;  // relative to thread_start_dtime
  int avg_interarrival_time;   // msecs
  int avg_rtt;                 // msecs   server: calcs from NACK
  // RTT is very unexact, since NACKs are recognized
  // only after an arrived pkt!
  int stream_bw;          // estimated bandwidth to stream one second in best quality
                          //    (normally, a little more than avg bw)
  int base_stream_bw;    // initial streamBW, not affected by switching
  OneStreamoutSecStat streamsec_stat[RTP_STAT_SECS]; //tracks the avg BW of
                                                     // the last few secs
  
  //BUFFER RELATED STUFF
  u32 client_preQ_max_size;  //maxium size of client-side preQ
  double buf_ahead_sec;      // estimated, how far is the buffer ahead to playout sec
  double prefetched_secs;    // how many secs were already spent in prefetching? 
                             // (at least RTP_PREFETCH_SECS at init)
  double stillToPrefetchSecs;// how many secs still have to be prefetched...
                             // (at least RTP_PREFETCH_SECS at init)
  
  //ADAPTATION RELATED STUFF
  double adapt_secs;  //normally 1.0, more or less to fill up/drain the 
                      // client buffer in adaptPreQ
  int adapt_rate;    // 100% if no adaptation... should be in the range of 70 - 100%
  
  //OTHER STAT STUFF
  ESInfo *es;
  FILE *streamout_stat_fp;
  FILE *playout_stat_fp;

};


#endif

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