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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

FilteredIO.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       FilteredIO.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 "FilteredIO.hpp"
#include "BitField.hpp"
#include "Frame.hpp"
#include "ESInfo.hpp"

FilteredIO::FilteredIO(IO* _io, BitField* _filter) 
{
        assert(_io && _filter);
        io=_io;
        filter=_filter;
        assert(filter->isAllSet());
        framesSeen=0;
};


FilteredIO::~FilteredIO()
{
        if(io)
                delete io;

        if(filter)
                delete filter;
};

Frame * FilteredIO::getFrame() {
        Frame* frm = NULL;
        bool  stop = false;
        u32 vopTimeIncrement = io->getESInfo()->getVOPTimeIncrement();
        do {
                frm=io->getFrame();
                if(frm) {
                        if(filter->getBit(frm->getAU()->cts/vopTimeIncrement) || (frm->getAU()->cts==0))
                                stop=true;
                        else {
                                dprintf_full("FilteredIO::getFrame: throwing away CTS %i VopIncr %i\n",frm->getAU()->cts,vopTimeIncrement);
                                delete frm;
                                frm=NULL;
                        }
                }
        } while(!stop && io->getState()!=IO::STREAMEOF && io->getState()!=IO::CLOSED &&
                                io->getState()!=IO::CLOSING && io->getState()!=IO::STREAMERR);
        framesSeen++;

#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield();
#else
        // for windows pthread lib!
#ifdef WIN32
#ifndef WINCE
        sched_yield();
#else
        Sleep(0);
#endif 
#endif
#endif
        dprintf_full("FilteredIO::getFrame() CTS %u\n",frm?frm->getAU()->cts:0);
        return frm;
};

int FilteredIO::writeFrame(Frame * frm, ESInfo *out_es) 
{
        assert(frm);
        framesSeen++;
        if(filter->getBit(frm->getAU()->cts/io->getESInfo()->getVOPTimeIncrement())) {
                return io->writeFrame(frm);
        }

#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

        return 1;
};

bool FilteredIO::open() 
{
        framesSeen=0;
        return io->open();
};

bool FilteredIO::close(bool immediate)
{
        return io->close(immediate);
};

long FilteredIO::setToClosestIFrame(u32 frameNumber, bool backwards)
{
        dprintf_full("FilteredIO::setToClosestIFrame\n");
        return io->setToClosestIFrame(frameNumber, backwards);
};

bool FilteredIO::destroy()
{
        return io->destroy();
};

IO::State FilteredIO::getState() const
{
        return io->getState();
};

IO::State FilteredIO::setState(IO::State s)
{
        return io->setState(s);
};

int FilteredIO::getBufferFillLevel() const
{
        return io->getBufferFillLevel();
};

int FilteredIO::flushBuffer(long from_ts, long to_ts)
{
        return io->flushBuffer(from_ts,to_ts);
};

const char *FilteredIO::getURL() const
{
        return io->getURL();
};

bool FilteredIO::setToFrameNumber(u32 frameNumber)
{
        dprintf_full("FilteredIO::setToFrameNumber\n");
        return io->setToFrameNumber(frameNumber);
};

void FilteredIO::setResendFrameHeader(bool set)
{
        io->setResendFrameHeader(set);
};

void FilteredIO::run()
{
        if(!io->running())
                io->start();
        io->wait();
};

void FilteredIO::setESInfo(ESInfo * es)
{
        io->setESInfo(es);
};

void FilteredIO::setRtxInfo(const rtx_info* rtx)
{
        io->setRtxInfo(rtx);
};

IO::State FilteredIO::play(double prefetchTime)
{
        return io->play(prefetchTime);
};

IO::State FilteredIO::pause()
{
        return io->pause();
};
IO::State FilteredIO::mute()
{
        return io->mute();
};

bool FilteredIO::setBitField(BitField* b)
{
        bool ret=false;
        if(b && b->getSize()>0) {
#ifdef DEBUG
                char* tmp=b->toHexString();
                dprintf_full("FilteredIO::setBitField %s\n",tmp);
                delete tmp;
#endif
                ret=(filter->getSize()==b->getSize());
                if(filter)
                        delete filter;
                filter=b;
        }
        return ret;
}

ESInfo* FilteredIO::getESInfo() {
        return io->getESInfo();
}

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