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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ProxySession.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: ProxySession.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_SESSION
#define _PS_PROXY_SESSION
#include "global.hpp"

#include "Session.hpp"
#include "Protocol.hpp"
#include "ContainerInfo.hpp"

#ifdef ISOMP4
#include "ISOMovies.h"
#endif

struct rtx_group;
class DataChannel;
class DataSink;
class IO;
class Url;
class ServerSession;
class RTSP;
class AdmissionControl;
class CacheManager;
#ifdef WIN32
//#include <winsock.h>
#else

#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#endif
#include "../metadata/TerminalCapabilities.hpp"
#include "PortGenerator.hpp"
#include "../SessionCounter.hpp"
typedef struct ProxyStatistics{
                u32 insertsIntoCM;
                u32 requests;
                u32 endedRequests;
                u32 qualHits;
                u32 rejected; //due to AC
                u32 rejectedDueToSize;
                u32 rejectedDueToLocking;
                u32 rejectedDueToErr;
                u32 deletedDueToLowQuality;
                u32 objHits;
                u32 objMiss;
                u64 bytesRequested;
                u64 bytesHit;
                ProxyStatistics() {
                        insertsIntoCM=requests=qualHits=deletedDueToLowQuality=
                                objHits=rejected=rejectedDueToLocking=rejectedDueToSize=0;
                        bytesRequested=bytesHit=0;
                        objMiss=rejectedDueToErr=endedRequests=0;
                };
                void saveStatisticTo(FILE* fp) {                
                        if(fp) {
                                fprintf(fp,"Requests: %u\nFinished Requests: %u\nInserts into CM: %u\n"
                                        "QualHits: %u\n ObjHits: %u\n ObjMiss: %u\n"
                                        "Rejected due to AdmissionControl: %u\n"
                                        "Rejected due to Locking: %u\n"
                                        "Rejected due to Size: %u\n"
                                        "Rejected due to other errors: %u\n"
                                        "Deleted due to low Quality: %u\n"
                                        "BytesReq(KB): %u\nBytesHit(KB): %u\n",
                                        requests,endedRequests,insertsIntoCM,
                                        qualHits,objHits,objMiss,
                                        rejected,
                                        rejectedDueToLocking,
                                        rejectedDueToSize,rejectedDueToErr,
                                        deletedDueToLowQuality,
                                        (u32)(bytesRequested/1024),(u32)(bytesHit/1024));
                        }
                };
        } ProxyStatistics;

extern ProxyStatistics prxStat;

class ProxySession:public Session {

public:
        

        ProxySession(int socket, const struct sockaddr_in *client, CacheManager * cm,
                AdmissionControl* adm, bool allowRTX,SessionCounter* counter=NULL,TerminalCapabilities* defTC=NULL);

        ~ProxySession();

        bool getOptions(const Url* fileName, const char* remaining) { dprintf_err("Proxy:getOptions not implemented"); return true;};

        bool setOptions(const Url* fileName, const char* remaining) { dprintf_err("Proxy:setOptions not implemented");return true;};

        bool options(const Url* fileName, const char* remaining);

  bool connect(const Url* fileName, const char* remaining);

        bool setup(const Url* fileName, const char* remaining);

        bool play(const Url* fileName, const char* remaining);

        bool pause(const Url* fileName, const char* remaining);

        bool tearDown(int sessionKey, bool immediate=false, const Url* fileName=NULL, const char* remaining=NULL);

        void run();

        void setUrl(const Url *uri, bool makeExactMatch = true);
  
        SessionState getState() const {
                return state;
        };

//      void setOutput(IO * out);
        
protected:
        int readData(char* buffer,int numBytes);
        ServerSession* serverSession;
        /* stores pairs of integers. 
        The first one is the sessionid from the proxy to the client.
        The 2nd form the server to the proxy */
        std::map<u32,u32,struct intCompare> sessionTranslator;
        CacheManager *cm;
        char buffer[MSG_BUFFER_SIZE + 1];
        char bufferBackup[MSG_BUFFER_SIZE + 1];
        struct sockaddr_in* server;

        bool rtxEnabledToServer;
        bool rtxEnabledToClient;
        bool rtxEnabled;
        bool delMp4Stream;
        char* playerId;
        list < rtx_info* > rtxInfoServer;
        bool insertMp4StreamIntoCM;
        
        bool dualMiss;
        bool dontCacheDualMiss;
        bool noDescribeSeenYet;
        SessionCounter* counter;
private:
        bool establishConnectionToServer();
        bool handleConnectHit(const Url* fileName);
        bool handleConnectMiss(const Url* fileName);
        DataSink* handleSetupHit(const Url* fileName, int esId, 
                                                                                                         int remoteClientPort, int remoteUpperClientPort,
                                                                                                         int remoteClientRtxPort, int sessionId,const char* protocol, const char* unicast);
        IO*  handleSetupMiss(const Url* fileName, int esId, int* sessionId);
        void detectRtxCapabilities();
        bool videoFullyCached(ContainerInfo* stream) const;
        bool esFullyCached(const ESInfo* es) const;
        AdmissionControl* admControl;

        
        ContainerInfo* origSrc;
        bool neverForwardMetaData;
        u32 origSrcReserved;
        u32 mp4StreamReserved;
};

#endif

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