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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

IncompleteIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       IncompleteIO.cpp                                              *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * 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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "IncompleteIO.hpp"
#include "MPGStreamIO.hpp"
#include "SimpleRtp.hpp"
#include "ESInfo.hpp"
#include "../net/PacketizationLayer.hpp"
#include "../net/Session.hpp"
#include "../metadata/TerminalCapabilities.hpp"
#include "../adaptors/GlobalTimer.hpp"

IncompleteIO::IncompleteIO(const char* localFile, const char *url, 
                        int remotePrt, const char *address, int localPrt, 
                        ESInfo * es, PacketizationLayer * packetization, bool writeOnly,
                        GlobalTimer * globalTimer, Statistics *stats):IO(),frameCache(INCOMPLETEIO__MAX_FRAMES)
{
        assert(es);
        this->es=es;
        vopTimeIncrement=es->getVOPTimeIncrement();
        dprintf_full("IncompleteIO::IncompleteIO with es=%p\n",es);
        //omitheader??? default is false, should be ok
        localInput=new MPGStreamIO(es,localFile,writeOnly); 
#ifndef WINCE
        remoteInput=new SimpleRtp(url, remotePrt, localPrt, address, es,
                packetization, writeOnly, NULL,true,SimpleRtp::NO_DELAY,false,false);
#endif //wince
        lastCTS=0;
        framesSeen=0;
        cacheUsage=0;
};

IncompleteIO::~IncompleteIO()
{
        if(localInput) {
                localInput->close(true);
                delete localInput;
        }
#ifndef WINCE
        if(remoteInput) {
                remoteInput->close(true);
                delete remoteInput;
        }
#endif
        flushLocalCache();


};

void IncompleteIO::flushLocalCache()
{       
        frameCache.flushBuffer();
};


long IncompleteIO::setToClosestIFrame(u32 frameNumber, bool backwards)
{
        return localInput->setToClosestIFrame(frameNumber, backwards);
};

Frame * IncompleteIO::getFrame()
{
        // first check the locally cached frames
        // then check MpgStreamIO
        // then try Rtp (blocking!)
        // then return from local cache
        dprintf_full("IncompleteIO::getFrame(): expecting CTS %u\n",(lastCTS==0)?0:lastCTS+vopTimeIncrement);

        // get packets from remote to avoid buffer overflow in Rtp
#ifndef WINCE
        remoteInput->preBufferPackets(0);
#endif
        if(lastCTS>=es->getDuration()) {
                dprintf_full("IncompleteIO::getFrame() eos detected\n");
                close(true);
                return NULL;
        }
        
        Frame* frm=NULL;
        // check the cache
        if(lastCTS==0)
                frm=findAndUnlinkFrame(0);
        else
                frm=findAndUnlinkFrame(vopTimeIncrement+lastCTS);

        if(frm) {
                lastCTS=frm->getAU()->cts;
                dprintf_full("IncompleteIO::getFrame(): found buffered frame with CTS %u\n",lastCTS);
                framesSeen++;
                return frm;
        }
        // it's not in the cache
        // so get the next frm from MpgStreamIO
        dprintf_full("IncompleteIO::getFrame(): before reading next local frame\n");
        frm=localInput->getFrame();
        dprintf_full("IncompleteIO::getFrame(): after reading local frame\n");
        if(!frm && framesSeen==0) {
                // header treatment
                frm=localInput->getFrame();
        }
                
        dprintf_full("IncompleteIO::getFrame(): read cached frame %p with CTS %u\n",frm, ( (frm && frm->getAU())?frm->getAU()->cts:0));
        if(frm) {
                if(frm->getAU()->cts==(lastCTS+vopTimeIncrement)
                        || frm->getAU()->cts==0) {
                        // found
                        framesSeen++;
                        if(frm->getAU()->cts!=0)
                                lastCTS=frm->getAU()->cts;
                        dprintf_full("IncompleteIO::getFrame(): local frame is returned\n");    
                        return frm;
                }
                else if(frm->getAU()->cts>lastCTS) {
                        // store in cache
                        setFrame(frm);
                        dprintf_full("IncompleteIO::getFrame(): local frame is cached\n");      
                }
                else {
                        delete frm; // frame is too old
                        dprintf_full("IncompleteIO::getFrame(): local frame is too old. Deleted!\n");   
                        frm=NULL;
                }
        }
        // if we have not found a local or cached frame, check network
#ifndef WINCE
        frm=remoteInput->getFrame();
#else
        frm = NULL;
#endif
        dprintf_full("IncompleteIO::getFrame(): read remote frame %p with CTS %u\n",frm, ( (frm && frm->getAU())?frm->getAU()->cts:0));
        if(frm) {
                if(frm->getAU()->cts==(lastCTS+vopTimeIncrement)
                        || frm->getAU()->cts==0) {
                        // found
                        framesSeen++;
                        if(frm->getAU()->cts!=0)
                                lastCTS=frm->getAU()->cts;
                        dprintf_full("IncompleteIO::getFrame(): remote frame is returned\n");           
                        return frm;
                }
                else if(frm->getAU()->cts>lastCTS) {
                        // store in cache
                        setFrame(frm);
                        dprintf_full("IncompleteIO::getFrame(): remote frame is cached\n");             
                }
                else {
                        delete frm; // frame is too old
                        dprintf_full("IncompleteIO::getFrame(): remote frame is too old. Deleted!\n");          
                }
        }
        frm=NULL;
        // we have to return sth
        // so look in the frameCache and return the first
        if(cacheUsage>0) {
                // search the cache for the next n frames
                // vopTimeIncrement+lastCTS was not found, thus check the next first
                u32 nextCTS=2*vopTimeIncrement+lastCTS;
                for(u32 iCts=nextCTS;iCts<nextCTS+INCOMPLETEIO__MAX_FRAME_LOOK_AHEAD*vopTimeIncrement;iCts+=vopTimeIncrement) {
                        frm=findAndUnlinkFrame(iCts);
                        if(frm) {
                                framesSeen++;
                                if(frm->getAU()->cts!=0)
                                        lastCTS=frm->getAU()->cts;
                                dprintf_full("IncompleteIO::getFrame(): gap detected, just returning the first cached frame %p with CTS %u\n",frm,frm->getAU()->cts);
                                return frm;     
                        };
                }
        }
        assert(frm==NULL);
        //we still have to increase lastCTS, otherwise infinite loop for one and the same CTS
        lastCTS+=vopTimeIncrement;
        dprintf_full("IncompleteIO::getFrame(): gap detected, returning NULL\n");
        return frm;
};

int IncompleteIO::writeFrame(Frame * frm, ESInfo *out_es)
{
        assert(false && "Not Implemented");
        return -1;
};

bool IncompleteIO::open()
{
        framesSeen=0;lastCTS=0;
#ifndef WINCE
        bool ret=localInput->open() && remoteInput->open();
#else
        bool ret = false;
#endif
        return ret;
};

bool IncompleteIO::close(bool immediate)
{
#ifndef WINCE
        bool ret=localInput->close(immediate) && remoteInput->close(immediate);
#else
        bool ret = false;
#endif
        return ret;
};

bool IncompleteIO::destroy()
{
        return localInput->destroy();
};

int IncompleteIO::getBufferFillLevel() const
{
#ifndef WINCE
        return remoteInput->getBufferFillLevel();
#else
        return 0;
#endif
};

int IncompleteIO::flushBuffer(long from_ts, long to_ts)
{
        int b=localInput->flushBuffer(from_ts,to_ts);
#ifndef WINCE
        b+=remoteInput->flushBuffer(from_ts,to_ts);
#endif
        this->flushLocalCache();
        return b;
};

const char *IncompleteIO::getURL() const
{
#ifndef WINCE
        return remoteInput->getURL();
#else
        return NULL;
#endif
};

bool IncompleteIO::setToFrameNumber(u32 frameNumber)
{
#ifndef WINCE
        bool ret=remoteInput->setToFrameNumber(frameNumber);
#else
        bool ret = false;
#endif
        // we don't care about remote
        ret=localInput->setToFrameNumber(frameNumber);
        
        return ret;
};

void IncompleteIO::setResendFrameHeader(bool set) 
{ 
        // one header is enough, so set this only at the local
        localInput->setResendFrameHeader(set);
};

void IncompleteIO::run()
{
#ifndef WINCE
        if(!remoteInput->running())
                remoteInput->start();
        remoteInput->wait();
#endif
};

void IncompleteIO::setRtxInfo(const rtx_info* rtx)
{
#ifndef WINCE
        remoteInput->setRtxInfo(rtx);
#endif
};

IO::State IncompleteIO::play(double prefetchTime) 
{ 

#ifndef WINCE
        localInput->play(prefetchTime);
        return remoteInput->play(prefetchTime);
#else
        return IO::CLOSED;
#endif
};

IO::State IncompleteIO::pause() 
{ 
        localInput->pause();
#ifndef WINCE
        return remoteInput->pause();
#else
        return IO::CLOSED;
#endif
};

IO::State IncompleteIO::setState(IO::State s)
{
        localInput->setState(s);
#ifndef WINCE
        return remoteInput->setState(s);
#else
        return IO::CLOSED;
#endif
};

IO::State IncompleteIO::getState() const 
{ 
#ifndef WINCE
        return remoteInput->getState();
#else
        return IO::CLOSED;
#endif
};

IO::State IncompleteIO::mute()
{
        localInput->mute();
#ifndef WINCE
        return  remoteInput->mute();
#else
        return IO::CLOSED;
#endif
};


Frame* IncompleteIO::findAndUnlinkFrame(u32 cts)
{
        Frame* frm=frameCache.get(cts);
        if(frm)
                        cacheUsage--;

        return frm;     
};

void IncompleteIO::setFrame(Frame* frm)
{
        assert(frm && frm->getAU());
        if(!frm)
                return;
        if(!frm->getAU())
                return;
        // auto deletes if cache is full
        frameCache.put(frm,frm->getAU()->cts);
        cacheUsage++;
        // correct for auto-delete
        if(cacheUsage>INCOMPLETEIO__MAX_FRAMES)
                cacheUsage=INCOMPLETEIO__MAX_FRAMES;

};

const ESInfo* const IncompleteIO::getESInfo() const
{
        return localInput->getESInfo();
};

void IncompleteIO::setESInfo(ESInfo * es)
{
        localInput->setESInfo(es);
#ifndef WINCE
        remoteInput->setESInfo(es);
#endif
};

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