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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

BufferedFileByteStream.cpp

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

#include "BufferedFileByteStream.hpp"

#ifndef WIN32
#include <sys/file.h> 
#endif
 
#ifndef WINCE
#include <errno.h>
#endif

BufferedFileByteStream::BufferedFileByteStream(const char* url, bool forReading) : ByteStream(url,forReading) {
        io = NULL;
}


bool BufferedFileByteStream::open() {
        if (io) { //already open....
                dprintf_err("BufferedFileByteStream::open: %s already open!\n",url);
                return true;
        }

        if (readOnly)
                io = fopen(url,"rb");
        else {
                io = fopen(url,"w");
#ifndef WIN32
                if (io) {
                        //make sure that we are the only writer system-wide!
                        int val = flock(fileno(io),LOCK_EX | LOCK_NB);
                        if (val == -1)
                                perror("BufferedFileByteStream::open flock out-file");
                        //ret = ((val == 0) || (errno == ENOLCK)); //eg. NFS might not support flocks
                        if (errno == EWOULDBLOCK) {
                                dprintf_err("MuxDemuxIO::open(): FATAL: lock on %s is held by other process! \n", url);
                                ::exit(1);
                        }
                }
#endif
        }

        if (!io) {
                dprintf_err("BufferedFileByteStream::open: file not found: %s!\n",url);
                return false;
        } else {
                buf_pos = buf_size = 0; //initialize buffer
                return true;
        }
}


bool BufferedFileByteStream::close() {
        if (!io)
                return false;
        else
                return fclose(io);
}

int BufferedFileByteStream::getChar() {
        if (!io)
                return false;

        return fgetc(io);
}


int BufferedFileByteStream::read(void *ptr, int size) {
        int ret = 0;
        int not_done=1;

        if (!io || !readOnly)
                return -1;

        //dprintf_full("BufferedFileByteStream::read PRE-refilling: buf_size %i\n",buf_size);

        if (size > buf_size) { //refill
                if (feof(io) || ferror(io))
                        return 0; //EOF... sorry...

                if (size < BUF_SIZE) { //only small frame request, do a prebuffer!
                        //dprintf_full("BufferedFileByteStream::read refilling: PRE-buf_size %i pos %i ret %i (req. size %i)\n",buf_size,buf_pos,ret,size);
                ret = fread((void*)((char*)buf+buf_pos+buf_size),1,BUF_SIZE,io);
                buf_size += ret;
                not_done = 1; //force ptr copying later
                //dprintf_full("BufferedFileByteStream::read refilling: buf_size %i pos %i ret %i (req. size %i)\n",buf_size,buf_pos,ret,size);
                } else { //copy big data directly to ptr
                        memcpy(ptr, buf+buf_pos, buf_size); //copy old buffer parts

                        ret = fread((void*)((char*)ptr+buf_size),       size - buf_size, 1, io);
                        ret += buf_size; //add old bytes to new file bytes
                        buf_size=buf_pos=0;
                        not_done = 0; //already filled the ptr....
                }
        }

        if (not_done == 1) { //take from old buffer
                assert(buf_size >= size);
                memcpy(ptr, buf+buf_pos, size);
                buf_size -= size;
                buf_pos += size;
                if (buf_pos >=  BUF_SIZE) { //move data to buffer front....
                        //dprintf_full("BufferedFileByteStream::read MOVING buffer (%i bytes) to front (OVERLAPPING? %i)\n",buf_size,buf_size>buf_pos);
                        memmove(buf, buf+buf_pos, buf_size);
                        buf_pos = 0;
                }

                ret = size;
        }

        //dprintf_full("BufferedFileByteStream::AFTER read buf_size %i, pos %i\n",buf_size,buf_pos);
        
        return ret;
}


int BufferedFileByteStream::write(void *ptr, int size){
        if (!io|| readOnly)
                return -1;

        int ret = fwrite(ptr,size,1,io);
        fflush(io);

        //assure that all bytes where written!
        if ( (ret < 1) || feof(io) || ferror(io) )
                return -1;

        return size;
}


int BufferedFileByteStream::seek(u64 pos) {
        if (!io)
                return -1;

        return fseek(io, pos, SEEK_SET);
}


u64 BufferedFileByteStream::tell() {
        if (!io)
                return 0;

        return ftell(io);
}

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