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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

CostFunction.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       CostFunction.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_COSTFUNCTION
#define PS_PROXY_COSTFUNCTION
#include "metadata/UserPreferences.hpp"
struct Request;

typedef struct ResourceUsage{
        double network;
        double disk;
        double cpu;
        ResourceUsage(double n,double d, double c)
        {
                network=n;
                disk=d;
                cpu=c;
        }
        ResourceUsage()
        {
                network=0.0;
                disk=0.0;
                cpu=0.0;
        }
        ResourceUsage(const ResourceUsage* u)
        {
                network=u->network;
                disk=u->disk;
                cpu=u->cpu;
        }
        void print(FILE* fp=stdout) {
                fprintf(fp,"N=%.2lfD=%.2lfC=%.2lf\n",network,disk,cpu);
        }
        void subtract(const ResourceUsage* u)
        {
                network-=u->network;
                disk-=u->disk;
                cpu-=u->cpu;
        }
        void add(const ResourceUsage* u)
        {
                network+=u->network;
                disk+=u->disk;
                cpu+=u->cpu;
        }
} ResourceUsage, ResourcePrices;

typedef struct ResourceLimit {
        int network;
        int disk;
        int cpu;
        ResourceLimit()
        {
                network=disk=cpu=0;
        };
        ResourceLimit(int net,int dsk,int cpU)
        {
                network=net;
                disk=dsk;
                cpu=cpU;
        }
        ResourceLimit(const ResourceLimit* l){
                network=l->network;
                disk=l->disk;
                cpu=l->cpu;
        }
} ResourceLimit;

class CostFunction {
public:
        static int baseCosts;
        static bool checkTranscoding(const Feature* origVideo, const Feature* target);
        static ResourceUsage* calcResourceUsage(const Feature* origVideo, 
                                                                const Feature* targetVideo, const ResourceLimit* r);

        static double calcWeightedMonetaryCosts(
                        const ResourceUsage* systemLoad, 
                        const ResourceUsage* req,
                        const ResourcePrices* prices,
                        int baseCosts,
                        int contentCosts,
                        int startUpDelayInMS, 
                        int maximumDelayInMS);

        static double calcFairMonetaryCosts(
                        const ResourceUsage* req, 
                        const ResourcePrices* priceInCent, 
                        int baseCosts, 
                        int contentCosts,
                        double videoduration);

        static double calcFinalCosts(double quality, double pay, double weightedcosts);
        static double calcFinalCosts(
                        const Request* origVideo, 
                        const Feature* targetVideo, 
                        const ResourceLimit* r,
                        const ResourceUsage* systemLoad,
                        const ResourcePrices* prices,int startupdelay);
        /* returns a newly allocated Feature. If the originl one is th best,
         * originalBest is set to true and a copy of the req->sourceVideo is returned */
        static Feature* findBestVariation(
                        const Request* req,
                        const ResourceUsage* systemLoad,
                        const ResourceLimit* r,
                        const ResourcePrices* prices, double* finalCosts, int delayToServer,bool* originalBest);

        static void cleanUserPreferences(UserPreferences* u, const Video* source);

        static int cpuCostDecoding(int dimX,int dimY, double fps)
        {
                return (int)(dimX*dimY*fps);
        }

        static int cpuCostEncoding(int dimX, int dimY, double fps)
        {
                return (int)(2*dimX*dimY*fps);
        };
        static int cpuCostResizing(int targetDimX, int targetDimY, double fps)
        {
                return (int)(targetDimX*targetDimY*fps*3.72);
        };
        static int cpuCostGreyscaling(int targetDimX, int targetDimY, double fps)
        {
                return (int)(targetDimX*targetDimY*fps*0.008);
        };
};

#endif

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