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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

RawStreamIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       RawStreamIO.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 "RawStreamIO.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
 
RawStreamIO::RawStreamIO(ESInfo * esi, const char *file, bool write) : IO() {
        if (!file)
                url = NULL;
        else {
                url = new char[strlen(file) + 1];
                strcpy(url, file);
        }
        writeOnly = write;
        lastCTSSeen=0;
        io = NULL;
        es = esi;
        atFileStart = true;
        state = CLOSED;
        currentFrameNumber=0;
        frameSize = 0;
}


RawStreamIO::~RawStreamIO() {
  if (state != CLOSED)
                close();
  if (io) {
#ifndef WIN32
                int val = flock(fileno(io),LOCK_UN);
                if (val == -1)
                        perror("RawStreamIO::destructor flock out-file");
#endif
                fclose(io);
                io=NULL;
        }
  if (url)
                delete[] url;
}

bool RawStreamIO::open() {      
        if(!url)
                return false;
        dprintf_full("RawStreamIO::open() Trying to open %s\r\n", url);
        if(state==OPEN)
                return true;

        bool ret = false;
        atFileStart = true;
        state = OPENING;  
        lastCTSSeen=0;
        char *name = new char[512];
        strcpy(name,url);
        strcat(name,".hint");

        if (writeOnly) {
        // we want to write to a local file
                // reset statistic
                dprintf_full("RawStreamIO::open(): resetting Statistic to %u dur %u ticks %u\n",es->getNumberOfMediaSamples(),(unsigned)es->getDuration(),es->getVOPTimeIncrement());
                es->disableFrameStatistic();
                es->enableFrameStatistic();
                io=fopen(url,"wb");
                ret = (io!=NULL);
                if (ret==true) {
#ifndef WIN32
                        int val = flock(fileno(io),LOCK_EX | LOCK_NB);
                        if (val == -1)
                                perror("RawStreamIO::open flock out-file");
                        ret = ((val == 0) || (errno == ENOLCK)); //eg. NFS might not support flocks
                        if (errno == EWOULDBLOCK) {
                                dprintf_err("RawStreamIO::open(): FATAL: lock on %s is held by other process! \n", url);
                                ::exit(1);
                        }
#endif
                        ;
                }
        } else {
                // we want to read from a local file 
                io=fopen(url,"rb");
                ret = (io!=NULL);
        }
        
        if (ret)
                state = OPEN;
        else
                state = CLOSED;
        currentFrameNumber=0;
        framesSeen=0;
        delete [] name;
        return ret;
}


bool RawStreamIO::close(bool immediate) {
  state = CLOSING;
  if (io) {
                fclose(io);
                io=NULL;
        }
        state = CLOSED;
        //      this->es->setDuration(lastCTSSeen+es->getVOPTimeIncrement());
  return true;
}


int RawStreamIO::writeFrame(Frame * frm, ESInfo *out_es) {
        dprintf_full("RawStreamIO::writeFrame %p\n",frm);
        // drop frames we have already written!!
        if ( (lastCTSSeen >= (signed)frm->getAU()->cts) && (lastCTSSeen != 0) ) {
                dprintf_small("RawStreamIO::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("RawStreamIO::writeFrame esID %llu Warning: Output is readonly or not open\n", es->getStreamId());
                return -1;
        }
  if (frm->getAU()->size == 0) {
                dprintf_small("RawStreamIO::writeFrame esID %llu: Cannot write zero sized frames\n", es->getStreamId());
                return 0;
  }

        dprintf_full("RawStreamIO::writeFrame: Saving %i bytes of CTS %i\n",
                                                         frm->getAU()->size, frm->getAU()->cts);
        // save the frame
        int i = fwrite(frm->getAU()->payload,sizeof(char), frm->getAU()->size , io);


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

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

        return ((signed)frm->getAU()->size == i);
}


void RawStreamIO::setFrameSize(u32 size) {
        frameSize = size;       
}
        

Frame *RawStreamIO::getFrame() {
        if (writeOnly || state != OPEN)
                return NULL;
        
        if (frameSize == 0) {
                dprintf_err("RawStreamIO::getFrame() has no frameSize, so use \"setFrameSize\" first!\n");
                ::exit(1);
        }
                
        if (atFileStart) {
                atFileStart = false;
                // return NULL;
  }
        // now read the frame
        // first check hintfile
        AU *au = new AU();
        Frame *frm = NULL;
        Frame::FrameType type = Frame::NN_VOP;
        
        au->size = frameSize;
        au->payload = new u8[frameSize];
        if (fread(au->payload,1,frameSize,io) < frameSize) {
                if (ferror(io)) {
#ifndef WINCE
                        perror("RawStreamIO::getFrame failed to read full frame");
#endif
                        state = STREAMERR;
                }
                else
                        state = STREAMEOF;
                return NULL;
        }
        au->cts = framesSeen * es->getVOPTimeIncrement();
        au->dts = au->cts;
        au->duration = es->getDuration();
        au->sampleFlags = 0;
        au->err = SA_OK;

  frm = new Frame(type);
  frm->setAU(au);
        frm->setMediaTimeScale(es->getMediaTimeScale());
        framesSeen++;
        currentFrameNumber++;
        dprintf_full("RawStreamIO::getFrame: file offset %li cts %i dts %i\r\n",ftell(io),au->cts,au->dts);

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

  return frm;
}


bool RawStreamIO::setToFrameNumber(u32 frameNumber) {
        // check if valid
        // e.g.: writeOnly streams can not be seeked 
        if(writeOnly || !io) {
                dprintf_full("RawStreamIO::setToFrameNumber(u32 %i) failed: not WriteClass or no Input IO\n",frameNumber);
                return false;
        }

        dprintf_full("RawStreamIO::setToFrameNumber(u32 %i)\r\n",frameNumber);
        fseek(io,frameSize * frameNumber,SEEK_SET);
        currentFrameNumber=frameNumber;

        if (frameNumber == 0)
                atFileStart = true;
        return true;
}


bool RawStreamIO::destroy() {
    // if we have a network connection we have got nothing to delete
    // so return true
  
    if (!io)
                return true;

    close();
#ifndef WINCE
    bool err = (remove(url) == 0);
#else
        bool err = (DeleteFile((LPCTSTR)url) != 0);
#endif

    return err;
}

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