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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

UserPreferences.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: UserPreferences.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 PS_PROXY_USERPREFERENCES_HPP
#define PS_PROXY_USERPREFERENCES_HPP
#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <cfloat>
#include <cstring>
#include <cmath>

#define BORDER_QUALITY 0.1f
#define MAXIMUM_ACCEPTABLE_DELAY 1000
#define DELAY_TO_SERVER 800
#include "VideoESInfo.hpp"

class TerminalCapabilities;
#include "net/Url.hpp"
#include "ContainerInfo.hpp"

typedef struct FeaturePoint{
        int point;
        double importance;
        FeaturePoint(const FeaturePoint& fp)
        {
                point=fp.point;importance=fp.importance;
        };
        FeaturePoint(const FeaturePoint* fp)
        {
                assert(fp);
                point=fp->point;importance=fp->importance;
        };
        FeaturePoint(int val,double imp) {
                point=val;
                importance=imp;
        };
        double calcPointQuality(int val) const{
                if(val==point)
                        return importance;
                return 0.0;
        };
        double calcQuality(int val) const{
                if(val<=0 || val>point)
                        return 0.0;
                return ((double)val)/point;
        };
        double calcInverseQuality(int val) const{
                if(val<0 || val>point)
                        return 0.0;
                return ((double)(point-val))/point*importance;  
        };
        static FeaturePoint* create(FILE* fp)
        {
                if(!fp)
                        return NULL;
        
                char temp[4960];
                if(fp==stdin) {
                        printf("\n(value)/importance: ");
                        fflush(stdout);
                }
                fgets(temp,4096,fp);
                return FeaturePoint::create(temp);

        }
        static FeaturePoint* create(const char* temp)
        {
                int val;double imp;
                if(2!=sscanf(temp, "(%i)/%lf", &val,&imp))
                        return NULL;
                return new FeaturePoint(val,imp);
        }
        char* toString() const{
                char* res=new char[32];
                sprintf(res,"(%i)/%lf",point,importance);
                return res;
        }
} FeaturePoint;

typedef struct FeatureRange{
        int best;
        int min;
        int max;
        double importance;
        FeatureRange(const FeatureRange& df)
        {
                best=df.best;min=df.min;max=df.max;importance=df.importance;
        };

        FeatureRange(const FeatureRange* df)
        {
                assert(df);
                best=df->best;min=df->min;max=df->max;importance=df->importance;
        };

        FeatureRange(int mn,int bst,int mx,double imp)
        {
                assert(mn<=bst && bst<=mx && 0.0<=imp && imp<=1.0);
                min=mn;best=bst;max=mx;importance=imp;
        };
        double calcQuality(int value) const
        {
                if(value<min || value>max)
                        return 0.0;

                if(value>=best) {
                        if(max==best) {
                                if(value==max)
                                        return importance;
                                else
                                        return 0.0;
                        }                       
                        return importance*((max-value)*(1.0-BORDER_QUALITY)/(max-best)+BORDER_QUALITY);
                }
                else {
                        if(best==min)
                                if(value==best)
                                        return importance;
                                else
                                        return 0.0;     
                        return importance*((value-min)*(1.0-BORDER_QUALITY)/(best-min)+BORDER_QUALITY);
                }
        };
        static FeatureRange* create(FILE* fp)
        {
                
                if(!fp)
                        return NULL;
        
                char temp[4960];
                if(fp==stdin) {
                        printf("\n(min,medium,max)/importance: ");
                        fflush(stdout);
                }
                fgets(temp,4096,fp);
                return FeatureRange::create(temp);

        };
        static FeatureRange* create(const char* buf)
        {
                int mn;int bst;int max;double imp;
                if(4!=sscanf(buf, "(%i,%i,%i)/%lf",&mn,&bst, &max,&imp))
                        return NULL;
                return new FeatureRange(mn,bst,max,imp);
        };
        char* toString() const{
                char* res=new char[32];
                sprintf(res,"(%i,%i,%i)/%lf",min,best,max,importance);
                return res;
        }
} FeatureRange; 

typedef struct Feature{

        char* url;
        int dimX;
        int dimY;
        int color;
        int bitrate;
        int numBFrames;
        int avgBFrameSize;
        double frameRate;
        double durationInSec;
        int isCached;
        int contentCosts;
        unsigned long lockedUntilTimePoint;
        
        Feature()
        {
                url=NULL;
                dimX=dimY=color=bitrate=numBFrames=avgBFrameSize=isCached=contentCosts=0;
                lockedUntilTimePoint=0;
                frameRate=durationInSec=0;
        };
        Feature(const VideoESInfo* vid)
        {
                url=NULL;
                bitrate=vid->getAvgBandwidth();
                durationInSec=vid->getDurationInMs()/1000.0;
                frameRate=(double)vid->getFPS();
                color= (vid->getHasColor()?1:0);
                dimX=vid->getWidth();
                dimY=vid->getHeight();
                if(vid->hasStaticFramePattern()) {
                        int bFramesBetween=vid->getNum_B_frames();
                        numBFrames=(int)(bFramesBetween*vid->getFPS()/(bFramesBetween+1));
                }
                else {
                        // assume every 5th frame to be a B-vop and using 10% data
                        numBFrames=(int)(vid->getFPS()/5);
                }       
                avgBFrameSize= (int)((vid->getAvgBFrameSize()*bitrate) / numBFrames);
                isCached=false;
                contentCosts=0;
                lockedUntilTimePoint=0;
        };
        Feature(const Feature& f) 
        {
                if(f.url) {
                        url=new char[strlen(f.url)+1];
                        strcpy(url,f.url);
                }
                else
                        url=NULL;
                dimX=f.dimX;
                dimY=f.dimY;
                color=f.color;
                isCached=f.isCached;
                bitrate=f.bitrate;
                frameRate=f.frameRate;
                numBFrames=f.numBFrames;
                avgBFrameSize=f.avgBFrameSize;
                durationInSec=f.durationInSec;
                contentCosts=f.contentCosts;
                lockedUntilTimePoint=f.lockedUntilTimePoint;
        }

        Feature(const Feature* f) 
        {
                if(f->url) {
                        url=new char[strlen(f->url)+1];
                        strcpy(url,f->url);
                }
                else
                        url=NULL;

                dimX=f->dimX;
                dimY=f->dimY;
                color=f->color;
                isCached=f->isCached;
                bitrate=f->bitrate;
                frameRate=f->frameRate;
                numBFrames=f->numBFrames;
                avgBFrameSize=f->avgBFrameSize;
                durationInSec=f->durationInSec;
                contentCosts=f->contentCosts;
                lockedUntilTimePoint=f->lockedUntilTimePoint;
        };

        Feature(int dx,int dy,int col,int br, int cached, int ccost,double fr, double dur)
        {
                dimX=dx;
                dimY=dy;
                color=col;
                isCached=cached;
                bitrate=br;
                frameRate=fr;
                numBFrames=(int)((frameRate-1.0)/2);
                avgBFrameSize=(int)(bitrate*0.2/numBFrames);
                durationInSec=dur;
                contentCosts=ccost;
                lockedUntilTimePoint=0;
                url=NULL;
        };

        Feature(const char* uri, int dx,int dy,int col,int br, int cached, int ccost,double fr, double dur)
        {
                assert(uri);
                url = new char[strlen(uri)+1];
                strcpy(url,uri);
                dimX=dx;
                dimY=dy;
                color=col;
                isCached=cached;
                bitrate=br;
                frameRate=fr;
                numBFrames=(int)((frameRate-1.0)/2);
                avgBFrameSize=(int)(bitrate*0.2/numBFrames);
                durationInSec=dur;
                contentCosts=ccost;
                lockedUntilTimePoint=0;
        };

        ~Feature()
        {
                if( url) delete[] url;
        };

        unsigned long getSizeInBytes() const {
                return ((unsigned long)(bitrate*(durationInSec/8.0)));
        }
        double getAspectRatio() const {
                return ((double)dimX)/dimY;
        }       
        bool canReduceBFramesToBitrate(int newbr,double* newFrameRate,int* newBitRate) const{
                assert(newFrameRate && newBitRate);
                *newFrameRate=0.0;
                *newBitRate=0;
                int br_diff=bitrate-newbr;
                if(br_diff>0) {
                        int dropFrames=(int)(floor( ((double)br_diff)/avgBFrameSize));
                        if(dropFrames>numBFrames)
                                return false;
                        *newFrameRate=numBFrames-dropFrames;
                        *newBitRate=bitrate-(dropFrames*avgBFrameSize);
                        return true;
                }
                return true;
        }
        bool reduceBFramesToBitrate(int newbr) {
                int br_diff=bitrate-newbr;
                if(br_diff>0) {
                        int dropFrames=(int)(floor( ((double)br_diff)/avgBFrameSize));
                        if(dropFrames>numBFrames)
                                return false;
                        numBFrames-=dropFrames;
                        bitrate-=(dropFrames*avgBFrameSize);
                        return true;
                }
                return true;
        }
        char* toString() {
                char* txt=new char[180];
                sprintf(txt,"(%i,%i,%i,%i,%.2lf/%i(%i bytes)):costs=%i:cached=%i:lockedTill=%lu\r\n",
                        dimX,dimY,bitrate,color,frameRate,numBFrames,avgBFrameSize,
                        contentCosts,isCached,lockedUntilTimePoint);
                return txt;
        }
        static Feature* create(FILE* fp)
        {
                if(!fp)
                        return NULL;
                int dimX,dimY,bitrate,isCached,color,contentCosts;
                double durationInSec,frameRate;
                char temp[4960];
                
                if(fp==stdin) {
                        printf("\ndimX dimY bitrate framerate durationInSec isCached(0 or 1) color(0 or 1) contentcost:");
                        fflush(stdout);
                }
                temp[0]='\0';
                fgets(temp,4096,fp);
                int i=sscanf(temp,"%i %i %i %lf %lf %i %i %i", &dimX,&dimY,&bitrate, 
                                        &frameRate, &durationInSec, &isCached, &color, &contentCosts);
                if(i==8)
                        return new Feature(dimX,dimY,color,bitrate,isCached, contentCosts, frameRate,durationInSec);
                
                return NULL;
        };              
} Feature, Video;       

typedef struct dFeatureRange{
        double best;
        double min;
        double max;
        double importance;

        dFeatureRange(const dFeatureRange& df)
        {
                best=df.best;min=df.min;max=df.max;importance=df.importance;
        };

        dFeatureRange(const dFeatureRange* df)
        {
                assert(df);
                best=df->best;min=df->min;max=df->max;importance=df->importance;
        };

        dFeatureRange(double mn,double bst,double mx,double imp)
        {
                assert(mn<=bst && bst<=mx && 0.0<=imp && imp<=1.0);
                min=mn;best=bst;max=mx;importance=imp;
        };

        double calcQuality(double value) const
        {
                if(value<min || value>max)
                        return 0.0;

                if(value>=best) {
                        if(fabs(max-best)<0.01) {
                                if(fabs(value-max)<0.01)
                                        return importance;
                                else
                                        return 0.0;
                        }                       
                        return importance*((max-value)*(1.0-BORDER_QUALITY)/(max-best)+BORDER_QUALITY);;
                }
                else {
                        if(fabs(best-min)<0.01)
                                if(fabs(value-best)<0.01)
                                        return importance;
                                else
                                        return 0.0;     
                        return importance*((value-min)*(1.0-BORDER_QUALITY)/(best-min)+BORDER_QUALITY);;
                }
        };
        static dFeatureRange* create(FILE* fp)
        {
                
                if(!fp)
                        return NULL;

                char temp[4960];
                if(fp==stdin) {
                        printf("\n(min,medium,max)/importance: ");
                        fflush(stdout);
                }
                fgets(temp,4096,fp);
                return dFeatureRange::create(temp);

        };
        static dFeatureRange* create(const char* buf)
        {
                double mn, bst, max;double imp;
                if(4!=sscanf(buf, "(%lf,%lf,%lf)/%lf",&mn,&bst, &max,&imp))
                        return NULL;
                return new dFeatureRange(mn,bst,max,imp);
        };
        char* toString() const {
                char* res=new char[64];
                sprintf(res,"(%lf,%lf,%lf)/%lf",min,best,max,importance);
                return res;
        }
} dFeatureRange;        

class UserPreferences
{
//FIXME protected:
public:
        FeatureRange dimX;
        FeatureRange bitrate;
        FeaturePoint delayInMS;
        FeaturePoint color;
        dFeatureRange frameRate;
        double pay;

public: 
        UserPreferences(const TerminalCapabilities* tc);
        UserPreferences(const UserPreferences* s);

        UserPreferences(const FeatureRange& dX,const FeatureRange& br, 
                const FeaturePoint& delay, const FeaturePoint& col, const dFeatureRange& fr,const double& pa);
        
        UserPreferences(const FeatureRange* dX, const FeatureRange* br, 
                const FeaturePoint* delay, const FeaturePoint* col, const dFeatureRange* fr,const double& pa);
        double calcQuality(const Feature* target, int delay) const;

        static UserPreferences* create(FILE* fp);

        static UserPreferences* create(const char* buf);

        void correctBitRate(int dimX, int dimY);

        void correctDimension();
        
        char* toString() const;

        static void doTest();
};




#endif

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