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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

BufferedIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       BufferedIO.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 "BufferedIO.hpp"
#include "Frame.hpp"
#include "ESInfo.hpp"
#include "IO.hpp"
#include "BitField.hpp"
#ifndef WINCE
#include <errno.h>
#endif
#ifndef WIN32
#include <sys/file.h> 
#endif
 
BufferedIO::BufferedIO(ESInfo * esi, MuxDemuxIO *muxio, bool write) : IO() {
        writeOnly = write;
        lastCTSSeen=0;
        es = esi;
        this->muxio = muxio;
        muxio->addBufferedIO(es->getStreamId(), this);

        atFileStart = true;
        state = CLOSED;
        currentFrameNumber=0;
}


BufferedIO::~BufferedIO() {
  if (state != CLOSED)
                close();
}

bool BufferedIO::open() {       
        bool ret = false;
        atFileStart = true;
        state = OPENING;  
        lastCTSSeen=0;

        if (writeOnly) {
                // reset statistic
                dprintf_full("BufferedIO::open(): resetting Statistic to %u dur %lli ticks %u\n",es->getNumberOfMediaSamples(),
                                                                 es->getDuration(), es->getVOPTimeIncrement());
                es->disableFrameStatistic();
                es->enableFrameStatistic();
        }

        ret = muxio->open();

        if (ret)
                state = OPEN;
        else
                state = CLOSED;

        currentFrameNumber=0;
        framesSeen=0;

        return ret;
}


bool BufferedIO::close(bool immediate) {
        dprintf_full("BufferedIO::close ES-ID %lli, immediate=%i, %i frames left in buffer\n",es->getStreamId(), immediate, buffer.size());

        if (state == CLOSED)
                return true;

  state = CLOSING;
        if (!immediate)
                while(!buffer.empty()) { //wait until MuxDemuxIO got everything...
                        dprintf_full("BufferedIO::close ES-ID %lli, %i frames left in buffer\n",es->getStreamId(), buffer.size());
                        //if (muxio->getNumberOfConnectedBufferedIO() == 1) //we are the last one, so poll empty
                        muxio->processFrame();
                        //              else
                        //sleep(1);
                }
        else
                buffer.clear();

        muxio->removeBufferedIO(es->getStreamId(), this);
        state = CLOSED;
  return true;
}


int BufferedIO::writeFrame(Frame * frm, ESInfo *out_es) {

        dprintf_full("BufferedIO::writeFrame %p, AU %p, ES-ID %lli\n",frm, frm->getAU(),es->getStreamId());
        // drop frames we have already written!!
        if ( (lastCTSSeen >= (signed)frm->getAU()->cts) && (lastCTSSeen != 0) ) {
                dprintf_small("BufferedIO::writeFrame WARNING: CTS %u already seen (lastCTSSeen %li) still writing to file!\n",
                                                                        frm->getAU()->cts,lastCTSSeen);
        } else
                lastCTSSeen = frm->getAU()->cts;
        
        if (!writeOnly || state != OPEN) {
                dprintf_small("BufferedIO::writeFrame esID %llu Warning: Output is readonly or not open\n", es->getStreamId());
                return -1;
        }
  if (frm->getAU()->size == 0) {
                dprintf_small("BufferedIO::writeFrame esID %llu: Cannot write zero sized frames\n", es->getStreamId());
                return 0;
  }

        dprintf_full("BufferedIO::writeFrame: Storing %i bytes of CTS %i into buffer (already holds %i frames)\n",
                                                         frm->getAU()->size, frm->getAU()->cts, buffer.size());

        es->getFrameStatistic()->setBit(frm->getAU()->cts/es->getVOPTimeIncrement());

        // buffer the frame FIFO style
        addToBuffer(frm);
        frm->markForDelete(false); //take away from DataChannel GarbageCollector, will be deleted in MuxDemuxIO

        muxio->processFrame();

        framesSeen++;

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

        return true;
}

s64 BufferedIO::nextCTSinBuf() {
        
        if (!buffer.empty()) {
                return buffer.front()->getAU()->cts;
        } else
                return -1;
}


Frame *BufferedIO::getFrame() {
        Frame *frm = NULL;

        dprintf_full("BufferedIO::getFrame: ES-ID %lli state %i, buffer: %i frames\n",es->getStreamId(), state, buffer.size());

        if ( (state != OPEN) && (state != CLOSING))
                return NULL;
        
        if (atFileStart) {
                atFileStart = false;
                // return NULL;
  }

        if (!writeOnly && muxio->getState() != STREAMEOF)
                muxio->processFrame();
        
        if (!buffer.empty()) {
                frm = buffer.front();
                buffer.pop_front();
                
                lastCTSSeen = frm->getAU()->cts;
                framesSeen++;
                currentFrameNumber++;
                dprintf_full("BufferedIO::getFrame: %p AU %p ES-ID %lli cts %i size %i, %i frames left in buffer\n", frm, frm->getAU(),
                                                                 es->getStreamId(), frm->getAU()->cts, frm->getAU()->size, buffer.size());
                
        } else { //buffer is empty
                if (muxio->getState() == OPEN) {
                        dprintf_full("BufferedIO::getFrame: ES-ID %lli no frame in buffer right now!\n",es->getStreamId());
                } else
                        state = muxio->getState(); //may be closed
        }
        
#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

  return frm;
}


bool BufferedIO::destroy() {
  
    close();

    return true;
}

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