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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

IO.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       IO.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_IO_HPP
#define _PS_PROXY_IO_HPP

#include "global.hpp"
#include <assert.h>
#ifdef ISOMP4
#include "ISOMovies.h"
#endif
//#include "VCondition.hpp"
#include "VMutex.hpp"

class ESInfo;
class Frame;
class VThread;


enum RTXState { NONE,ACK,NACK,NACKACK};
#define LAST_RTX_STATE NACKACK
extern char* sRTXState[];

        typedef struct rtx_info {
                //address is taken from RTP data stream
                u16 remotePort;
                u16 localPort;
                struct rtp *session;
                u16 payloadType;
                u32 ticks;
                u32 mId;
                u32 rtxTimeInMs;
                RTXState state;
                rtx_info() {
                        rtxTimeInMs=0;
                        state=NONE;
                        ticks=payloadType=remotePort=localPort=mId=0;
                        session=NULL;
                };
                rtx_info(RTXState type,u32 maxTime) {
                        rtxTimeInMs=maxTime;
                        state=type;
                        ticks=payloadType=remotePort=localPort=mId=0;
                        session=NULL;
                };
                rtx_info(const rtx_info* r) {
                        assert(r);
                        remotePort  = r->remotePort; 
                        localPort   = r->localPort;
                        payloadType = r->payloadType;
                        ticks       = r->ticks;
                        mId         = r->mId;
                        rtxTimeInMs = r->rtxTimeInMs;
                        state       = r->state;
                        session     = NULL;
                }   
                ~rtx_info()
                {
                };
        } rtx_info;

        typedef struct rtx_group {
                u32 midESInfo;
                rtx_info* rtx;
                const ESInfo* es;

                rtx_group(RTXState type,u32 maxTime) {
                        rtx=new rtx_info(type,maxTime);
                        es=NULL;
                        midESInfo=0;
                };
                ~rtx_group() {
                        if(rtx)
                                delete rtx;
                };
        } rtx_group;

enum Error { SA_OK, SA_Error, SA_EOF };
struct AU {
        u8 *payload;
        u8 *y,*u,*v; // on linux point to the components in the payload, on winCE it uses three diff. buffers
        u32 size;
        u32 cts;
        u32 dts;
        u32 duration;
        u32 sampleFlags;
        u8 prio;
        u32 frameType;
        Error err;

        char *toString() {
                int auSize = sizeof(AU) - sizeof(u8 *);
                char *res = new char[auSize];
                memcpy(res, &size, auSize);
                return res;
        };
        bool fromString(char *in) {
                memcpy(&size, in, sizeof(AU) - sizeof(u8 *));
                payload = NULL;
                return true;
        };
        bool operator == (const AU & a1) {
                return a1.size == size && a1.cts == cts && a1.dts == dts
            && a1.duration == duration && a1.prio == prio;
        };
        bool operator == (const AU * &a1) {
                return a1->size == size && a1->cts == cts && a1->dts == dts
            && a1->duration == duration && a1->prio == prio;
        };
        AU() {
                payload=NULL;
                size = 0;
                cts = 0;
                dts = 0;
                duration = 0;
                sampleFlags = 0;
                prio = 255;
                frameType=0;
                err = SA_OK;
        };
        AU(const AU & in) {
                payload=NULL;
                size = 0;
                cts = in.cts;
                dts = in.dts;
                duration = in.duration;
                sampleFlags = in.sampleFlags;
                prio = in.prio;
                frameType=in.frameType;
                err = in.err;
        };
        AU(const AU * in) {
                payload=NULL;
                size = 0;
                cts = in->cts;
                dts = in->dts;
                duration = in->duration;
                sampleFlags = in->sampleFlags;
                prio = in->prio;
                frameType=in->frameType;
                err = in->err;
        };
        ~AU() {
                if(payload) {
                        delete[] payload;
                        payload=NULL;
                }
        };

};

class IO: public VThread {
        
public:
  /* OPEN and MUTED means playing and streaming, adapting in the DC and in the DataSinks,
         *      but MUTED does all except adaptation in the DataSinks, where the decoding normally
         *      takes place...still, the I/O output writeFrame is called with the unadapted frame!
   *      by this, global DC adaptors might still be used for eg. statistics
         * PAUSED is kinda like CLOSED, not playing and streaming, but it could be continued
         * PREFETCHING is used at beginning or on buffer underrun
         * STREAMERR is set, if eg. no header was received or, for the Rtp class, 
         *                                                  the rtp udp ports where already in use 
         *
         * StateInNumbers: 0,      1,          2,         3,      4,     5,      6,       7,           8,         9
         */
        enum    State { CLOSED, CLOSING, FORCE_CLOSING, OPENING, OPEN, PAUSED, MUTED, PREFETCHING, STREAMEOF, STREAMERR };

#define IO_NETWORK_HIGHEST_PRIORITY 0

        IO();

        virtual ~IO();

        virtual Frame * getFrame() = 0;

        virtual int writeFrame(Frame * frm, ESInfo *es = NULL) = 0;

        virtual bool open() = 0;

        virtual bool close(bool immediate=false) = 0;

        virtual bool destroy() = 0;

        virtual State getState() const { return state;};

        virtual State setState(State s);

        virtual int getBufferFillLevel() const = 0;

        virtual int flushBuffer(long from_ts = 0, long to_ts = -1)
        {
                from_ts = from_ts;      // 4Wall
                to_ts = to_ts;          // 4Wall
                return 0;
        };

        virtual const char *getURL() const = 0;

        virtual bool setToFrameNumber(u32 frameNumber) {
                dprintf_full("IO::setToFrameNumber dummy implementation\n");
                return false;
        };

        virtual long setToClosestIFrame(u32 frameNumber, bool backwards = true) {
                dprintf_full("IO::setToClosestIFrame dummy implementation\n");
                setToFrameNumber(frameNumber);
                backwards = backwards;
                return 0;
        };

        virtual bool setEndFrameNumber(u32 stopNumber) {
                endFrameNumber=stopNumber;
                return true;
        }

        virtual u32 getEndFrameNumber() const { return endFrameNumber; }

        virtual u32 getCurrentFrameNumber() const {     return currentFrameNumber; };

        virtual void setResendFrameHeader(bool set) { resendFrameHeader=set;};

        virtual void run() { ; }; //immediately stop unused thread

        virtual void setESInfo(ESInfo * es) =0;

        virtual ESInfo* getESInfo() =0;

        virtual u32 getFramesSeen() const { return framesSeen;};

        virtual void setRtxInfo(const rtx_info* rtx) { rtx = rtx; };

        //stupid default implementations...
        virtual State play(double prefetchTime=0.0); //implemented in IO.cpp

        virtual State pause();

        virtual State mute();

protected:

        State state;
        bool resendFrameHeader;
        u32 currentFrameNumber;
        u32 endFrameNumber;
        VMutex mutexStateChanged;
//      VCondition condStateChanged;
        u32 framesSeen;
};
#endif

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