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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MPGStreamIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MPGStreamIO.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 "MPGStreamIO.hpp"
#include "VideoESInfo.hpp"
#include "CompressedVideoFrame.hpp"
#include "CompressedAudioFrame.hpp"
#include "IO.hpp"
#include "../net/SDP.hpp"
#include "BitField.hpp"

#include "../container/ISOMP4ContainerFile.hpp"

MPGStreamIO::MPGStreamIO(ESInfo * esi, const char *file, bool write, bool omit):IO() {
        dprintf_full("MPGStreamIO::MPGStreamIO file=%s writeonly=%s\n",(file?file:"NULL"),(write?"WRITE":"READ"));
        assert(esi);
        writeOnly=write;
        omitHeader = omit;
        if (!file)
                url = NULL;
        else {
                url = new char[strlen(file) + 1];
                strcpy(url, file);
        }
        lastCTSSeen=0;
        io = NULL;
        es = esi;
        helpFile = NULL;
        writeHelpFile = true;
        atFileStart = true;
        state = CLOSED;
        currentFrameNumber=0;
        endFrameNumber=0;
}


MPGStreamIO::~MPGStreamIO() {
        dprintf_full("MPGStreamIO::~MPGStreamIO()\n");
  if (state != CLOSED)
                close();
  if (io) {
                dprintf_full("MPGStreamIO::~MPGStreamIO() closed file in destr.\n");
                fclose(io);
                io=NULL;
        }
  if (helpFile)
                fclose(helpFile);

  if (url)
                delete[] url;
}


bool MPGStreamIO::open() {
        
        if(!url) {
                // try to get localfile from esinfo
                const char* tmpUrl=es->getInput();
                if(tmpUrl) {
                        url=new char[strlen(tmpUrl)+1];
                        strcpy(url,tmpUrl);
                }
                else    
                        return false;
        }
                
        dprintf_full("MPGStreamIO::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("MPGStreamIO::open(): resetting Statistic to %u dur %u ticks %u\n",
                             es->getNumberOfMediaSamples(),(unsigned)es->getDuration(),
                             es->getVOPTimeIncrement());
                es->disableFrameStatistic();
                es->enableFrameStatistic();
        if (writeHelpFile) {
                if(helpFile)
                        fclose(helpFile);
                helpFile = fopen(name,"wb");
                if (!helpFile) {
                        helpFile = NULL;
                        writeHelpFile = false;
                }
        }
        if(io) {
                // safety check, shouldn't happen
                fclose(io);
        }
        io=fopen(url,"wb");
        ret = (io!=NULL);
        } else {
        // we want to read from a local file 
        if (writeHelpFile) {    
                helpFile = fopen(name,"rb");
                if (helpFile) {
                        fseek(helpFile,0,SEEK_END);
                        if (ftell(helpFile) == 0){ //zero length
                                fclose(helpFile);
                                helpFile = NULL;
                        } else
                                fseek(helpFile,0,SEEK_SET);
                }

                if (!helpFile) {
                        dprintf_full("MPGStreamIO::open   no valid .hint file found, ignoring...\n");
                        helpFile = NULL;
                        writeHelpFile = false;
                } else {
                        dprintf_full("MPGStreamIO::open   using and relying on .hint file %s\n",name);
                }
        }
        io=fopen(url,"rb");
        ret = (io!=NULL);
        }

        if (ret)
        state = OPEN;
        else
        state = CLOSED;
        currentFrameNumber=0;
        framesSeen=0;
        delete [] name;
        return ret;
}


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


int MPGStreamIO::writeFrame(Frame * frm, ESInfo *out_es) {
        if(!frm)
                return 0;

        if (!writeOnly || state != OPEN) {
                dprintf_small("MPGStreamIO esID %llu Warning: Output is readonly or not open\n", es->getStreamId());
                return -1;
        }


        
        // drop frames we have already written!!
        if(lastCTSSeen>=frm->getAU()->cts && lastCTSSeen!=0) {
                dprintf_small("MPGStreamIO::writeFrame Dropping Frame %u\n",frm->getAU()->cts);
                return 0;
        }
        else
                lastCTSSeen=frm->getAU()->cts;

        if (frm->getAU()->size == 0) {
                dprintf_small("MPGStreamIO::writeFrame esID %llu: Cannot write zero sized frames\n", es->getStreamId());
                return 0;
        }

        u32 frmBitIndex=frm->getAU()->cts/es->getVOPTimeIncrement();
        dprintf_full("MPGStreamIO::writeFrame CTS %u(%u), size %u(%u %u %u %u...), VOPINC %u\n",
                frm->getAU()->cts,frmBitIndex,frm->getAU()->size,frm->getAU()->payload[0],
                frm->getAU()->payload[1],frm->getAU()->payload[2],frm->getAU()->payload[3],
                es->getVOPTimeIncrement());
        
        // write header right in front of first frame!!!
        if (atFileStart && !omitHeader) {
                atFileStart = false;
                if (!saveHeader()) {
            dprintf_small("MPGStreamIO::writeFrame esID %llu: failed to save header\n", es->getStreamId());
            return -1;
                }
  }
        
        // save the frame
        int i = (frm->getAU()->size ==  
                                         fwrite(frm->getAU()->payload,sizeof(char), frm->getAU()->size,io));
        framesSeen++;
        es->getFrameStatistic()->setBit(frmBitIndex);
        if (writeHelpFile)
                writeHelpInfo(frm);
#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield();
#else
        // for windows pthread lib!
#ifndef WINCE
        sched_yield();
#else
        Sleep(0);
#endif
#endif

        return i;
}


Frame *MPGStreamIO::getFrame() {
        if (writeOnly || state != OPEN)
                return NULL;
 
        if (atFileStart) {
                atFileStart = false;
                //FIXME: why we need to call this for audiostream also?
                //if (es->isVisualStream()) {
                        if (!readHeader())
                                state=STREAMERR;
                        return NULL;
                //}
  }
        if (( (this->currentFrameNumber > this->endFrameNumber) && (endFrameNumber!=0) ) || feof(io)) {
                close(true);
                state=STREAMEOF;
                return NULL;
        }

        // now read the frame
        // first check hintfile
        AU *au = new AU();
        Frame *frm = NULL;
        Frame::FrameType type = Frame::NN_VOP;

        if (writeHelpFile) {
                // read one AU entry from the file
                int auSize = sizeof(AU) - sizeof(u8 *);
                int tmp = 0;
                if (auSize !=   (tmp = fread((char *) &(au->size),sizeof(char),auSize,helpFile))) {
            if (tmp <= 0) {
                                // last frame
                                state = STREAMEOF;
                                delete au;
                                return NULL;
            }
            dprintf_err("MPGStreamIO::getFrame() esID %llu: Mismatch in hintfile. Expected %i bytes, but just got %i?\r\n",
                                                                        es->getStreamId(), auSize, tmp);
            
                        state = STREAMEOF;
                        delete au;
                        return NULL;
                }
                else {          // au is correct
            // read the AU
            au->payload = new u8[au->size];
                        assert(au->payload);
            if ((unsigned long) au->size != fread(au->payload,sizeof(char),au->size,io)) {
                                dprintf_err("MPGStreamIO::getFrame(): Mismatch in data & hintfile. Not enough data?\r\n");
                                delete au;
                                state= STREAMERR;
                                return NULL;
                        }
                        dprintf_full("MPGStreamIO::getFrame(): got hinted info CTS %i prio: %i\n",au->cts,au->prio);
                }
  }
        else {                  // no help stream available, how to calc cts and dts?

                // parse MPGFile for VOB_Code if it is a visual stream
                // FIXME: do Audio streams have a different VOP Code??

                if(es->isVisualStream()) {
                        // 00 00 01 182 dec -> 0x1B6 (=438 dec)
                        u32 code = 2000;        // don't init to 0, we want the code from the 2nd frame, not the first
                        int ch;
                        int i = 0;
                        char *data = new char[MAX_FRAME_SIZE];
                        do {
                                ch = getc(io);
                                data[i] = (u8)ch;
                                i++;
                                code = (code << 8) | (u8)ch;
                                                if ((i==4) && code == VOP_START_CODE)
                                                        code =0; //correct beginning, parse until next START_CODE
                        }
                        while ((i < MAX_FRAME_SIZE) && (ch != EOF) && (code != VOP_START_CODE));

                        if (code == VOP_START_CODE) {
                        // put back the VOP_HEADER
                                        // seek back 4 bytes
                                fseek(io, -4, SEEK_CUR);
                                au->size = i;
                        }

                        if (au->size == 0) {
                                state = STREAMEOF;
                                delete au;
                                return NULL;
                        }

                        au->payload = new u8[i];
                        memcpy(au->payload, data, i);
                        au->prio = IO_NETWORK_HIGHEST_PRIORITY;
                        au->duration = es->getVOPTimeIncrement();
                        au->cts = currentFrameNumber * es->getVOPTimeIncrement();
                        au->dts = currentFrameNumber * es->getVOPTimeIncrement();
                        au->sampleFlags = 0;
                        if (code != VOP_START_CODE)
                                au->err = SA_EOF;
                        else
                                au->err = SA_OK;


                        delete data;
                }
        
                if(es->isAudioStream()) { //XXX not sure if it works properly
                        dprintf_err("MPGStreamIO  audioStream parsing\n\n");
                        // start code for MP3 frame is 11111111 111 (first 11 bits set) 
                        u32 code = 2000;        // don't init to 0, we want the code from the 2nd frame, not the first
                        int ch;
                        int i = 0;
                        char *data = new char[165536];
                        do {
                                ch = getc(io);
                                data[i] = ch;
                                i++;
                                code = (code << 8) | ch;
                        }
                        while ((ch != -1) && 
                                                 (code>>21 != 0x000007FF /*VOP_START_CODE for audio(actually MP3)*/))
                                ;
                        if (code>>21 == 0x000007FF /*VOP_START_CODE*/) {
                                // put back the VOP_HEADER
                                // seek back 4 bytes
                                fseek(io, -4, SEEK_CUR);
                                /*
                                        ungetc(182,io);
                                        ungetc(1,io);
                                        ungetc(0,io);
                                        ungetc(0,io); */
                                au->size = i;
                        }
                        au->payload = new u8[i];
                        memcpy(au->payload, data, i);
                        au->cts = 0;
                        au->dts = 0;
                        au->duration = 0;
                        au->sampleFlags = 0;
                        if (code>>21 != 0x000007FF /*VOP_START_CODE*/)
                                au->err = SA_EOF;
                        else
                                au->err = SA_OK;
                        
                        delete [] data;
                }
  }
        
        
        //FIXME: quickhack to assign priorities, if no Hint file is avail (eg. direct access to .cmp files!)
  if (es->isVisualStream() && !writeHelpFile) { 
                if (au->payload[0] == 0 && au->payload[1] == 0 &&
                                au->payload[2] == 1 && au->payload[3] == 182) {
            type = (Frame::FrameType) ((au->payload[4]) >> 6);
                        if (type == Frame::I_VOP || type == Frame::P_VOP)
                                au->prio = IO_NETWORK_HIGHEST_PRIORITY;
                        else 
                                au->prio = ~IO_NETWORK_HIGHEST_PRIORITY;
                }
  }
        
        // frame types will be detected in frm->setAU()!

        if(es->isVisualStream())
                frm = new CompressedVideoFrame(type, ((VideoESInfo*)es)->getWidth(), ((VideoESInfo*)es)->getHeight());
        else if(es->isAudioStream())
                frm=new CompressedAudioFrame(type);
        else
                frm = new CompressedVideoFrame(type, 0, 0);
  frm->setAU(au);
        frm->setMediaTimeScale(es->getMediaTimeScale());
        framesSeen++;
        currentFrameNumber++;
        dprintf_full("MPGStreamIO::getFrame: file offset %li cts %i dts %i type %s (%x %x %x %x) size %i, frameNo %u\r\n",
                                                         ftell(io),au->cts,au->dts,
                                                         Frame::VOPTypeToChar((Frame::VOP_TYPE)frm->getAU()->frameType),
                                                         frm->getAU()->payload[0],frm->getAU()->payload[1],frm->getAU()->payload[2],frm->getAU()->payload[3],
                                                         frm->getAU()->size,
                                                         getCurrentFrameNumber());

#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield();
#else
        // for windows pthread lib!
#ifdef WIN32
#ifndef WINCE
        sched_yield();
#else
        Sleep(0);
#endif
#endif
#endif

  return frm;
}


bool MPGStreamIO::saveHeader() {
        int size;

        // if we have a network connection we never write the header into
        // the data stream, the header is typically found in the SDP desc.
        dprintf_full("MPGStreamIO::saveHeader\n");
        if (!io)
                return true;

  const u8 *encConf = es->getEncodedDecoderConfig();
  if (!encConf || (size = strlen((const char *) encConf)) == 0) {
                dprintf_err("MPGStreamIO::saveHeader esID %llu: Failed to get EncodedDecoderConfig, got %s\n",
                                                                es->getStreamId(), encConf);
                return false;
        }

        u8 *decConf = new u8[size / 2+1];
        SDP::decodeDecoderConfig(decConf, encConf, size);
        // problem: decoderConfig is some extended Header
        // we have some leading bytes, and then we have 00 00 01h, the start of the header
        // so search for this hex value
        int i = 0;
        u32 data = 0xFFFFFFFF;
        u32 offset = 0;
        // generic streams have different headers 
        if (!es->isVisualStream() && !es->isAudioStream()) {
                i = size / 2;
        }
        
        bool headerFound=false;
        while (i < size / 2 - 1) {
                printf("%x\t",data);
                data <<= 8;
                data += decConf[i];
                i++;
                if (data != 0x00000100) {
                        headerFound = true;
                        break;
                }
        }
  if (headerFound) {    // we have read 2 zeros followed by a 1
                // set offset to point to the first 0
                // i points after the 1 -> header is 00 00 01 xx-> reduce by 3
                // 00 01 02 03 00 00 01 xx -> i=7 -> i=4
                if (i > (signed)sizeof(data))
                        offset = i - sizeof(data) + 1;
                else 
                        offset = 0;

                dprintf_full("MPGStreamIO: Found header in decconf %x at offset %i\n", data, offset);
                // save the header to the hintstream if possible
                if (helpFile) {
            // first save the size of the decoder config
            char intTemp[20];
            intTemp[0] = 0;
            sprintf(intTemp, "%i\n", size / 2);
                        fwrite(intTemp, 1, strlen(intTemp), helpFile);
            // then save the decoder config
                        fwrite(decConf,1, size/2,helpFile);
                }
        } else {
                dprintf_err("MPGStreamIO::saveHeader: Missing Header for esID %llu\n",  es->getStreamId());
                fwrite("0\n", 1, 2, helpFile);
        }
        bool ret = ((size / 2 - offset) == ((u32)fwrite((char *) (decConf + offset), 1, size / 2 - offset, io)));
        dprintf_full("MPGStreamIO::saveHeader: Offset is %i, first 4 bytes are %x %x %x %x, status: %s\n",
                                                         offset, decConf[offset], decConf[offset + 1], decConf[offset + 2],
                                                         decConf[offset + 3], ret?"written":"WRITE FAILED");
        if (writeHelpFile) {
                char tmp[20];
                tmp[0]=0;
                sprintf(tmp, "%i\n",(size / 2 - offset));
                fwrite(tmp,1,strlen(tmp),helpFile);             
        }
        
        delete[] decConf;
        return ret;
}


bool MPGStreamIO::readHeader() {
        char *header = new char[MAX_HEADERS_SIZE];

        if (!io) {
                dprintf_full("MPGStreamIO::readHeader: cannot read header from network device\n");
                delete [] header;
                return true;
        }
        int headerSize = 0;
        int extHeaderSize = 0;
        long currentHelpPos=0;

        if (writeHelpFile) {
                // Format: <size of the extended header> \n <extendedheader> <headerSize>\n
                // read the headerSize from the helpFile

                if(helpFile)
                        currentHelpPos=ftell(helpFile);

                fseek(helpFile,0, SEEK_SET);

                char line[20];
                if (fgets(line,20, helpFile) != NULL) {
                        dprintf_full("DecConf Size is %s\n", line);
                        if (sscanf(line, "%i", &extHeaderSize) != 1)
                                extHeaderSize = 0;
                        else {
                                // we know the ext header size          
                                // extract header
                                if (extHeaderSize > 0
                                        && extHeaderSize == (signed)fread(header,1,extHeaderSize,helpFile))
                                {
                                        header[extHeaderSize] = 0;
                                        es->setDecoderConfig((u8 *) header, extHeaderSize);
                                }
                        }
                        // now read the header size
                        if (fgets(line,20, helpFile) != NULL) {
                                if (sscanf(line, "%i", &headerSize) != 1)
                                        headerSize = 0;
                        }
                }
        }
  if (headerSize == 0) {        // FIXME: header!=decoderConfig -> we loose part of the decConf in this case
                // parse MPGFile for first VOB_Code
                // 0d 0d 1d 182d -> 0x1B6
                u32 code = 0;
                int ch;
                int i = 0;
                fseek(io, 0, SEEK_SET);
                do {
                        ch = fgetc(io);
                        header[i] = ch;
                        i++;
                        code = (code << 8) | (u8)ch;
                        //                      dprintf_err("MPGStreamIO::readHeader %i %x  %x\n",i,ch, code);
                }
                while ((i<MAX_HEADERS_SIZE) && (ch != EOF) && (code != VOP_START_CODE));

                if (code != VOP_START_CODE) {
                        dprintf_err("MPGStreamIO::readHeader Error: not even one VOP_START_CODE found!\r\n");
                        if(currentHelpPos>0)
                                fseek(helpFile,currentHelpPos,SEEK_SET);
                        delete [] header;
                        return false;
                }
                // put back the first VOP_HEADER
                fseek(io, -4, SEEK_CUR);

                headerSize = ftell(io);
                header[headerSize] = 0;
                // set header
                if (extHeaderSize == 0)
                        es->setDecoderConfig((u8 *) header, headerSize);
                if(currentHelpPos>0)
                        fseek(helpFile,currentHelpPos,SEEK_SET);
                delete [] header;
                return true;
        } else {
                // we know the header size              
                // skip header
                if (headerSize == (signed)fread(header, 1, headerSize, io)) {
                        if(currentHelpPos>0)
                                fseek(helpFile,currentHelpPos,SEEK_SET);
                        delete [] header;
                        return true;
                }
        }
  dprintf_err("MPGStreamIO:readHeader: Should never happen :-D");
        if(currentHelpPos>0)
                fseek(helpFile,currentHelpPos,SEEK_SET);
  delete [] header;
  return false;
}


void MPGStreamIO::writeHelpInfo(const Frame * frm) {
        // write one AU
        char *temp = frm->getAU()->toString();
        int size = sizeof(AU) - sizeof(u8 *);
        fwrite(temp,1,size,helpFile);
        delete[] temp;
}


bool MPGStreamIO::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
    if (helpFile) {
                char *name = new char[512];
                strcpy(name,url);
                strcat(name,".hint");
#ifndef WINCE
                err &= (remove(name) == 0);
#else
                err &= (DeleteFile((LPCTSTR)name) != 0);
#endif
                delete [] name;
    }

    return err;
}


bool MPGStreamIO::setToFrameNumber(u32 frameNumber) {
        // check if valid
        // e.g.: writeOnly streams can not be seeked 
        if(writeOnly) { 
                dprintf_err("MPGStreamIO::setToFrameNumber(u32 %i) failed: MPGStreamIO opened for writing\n",frameNumber);
                return false;
        }
        dprintf_full("MPGStreamIO::setToFrameNumber: current is %i, new is %i\n",currentFrameNumber,frameNumber);
        if(!io) {
                // shouldn't happen??? reset class
                dprintf_small("MPGStreamIO::setToFrameNumber(u32 %i): called on closed MPGStreamIO\n",frameNumber);
                close(true);
                open();
        }
        if(!io) {
                dprintf_err("MPGStreamIO::setToFrameNumber(u32 %i) failed: couldn't open input %s?\n",frameNumber,url);
                return false;
        }
        dprintf_full("MPGStreamIO::setToFrameNumber(u32 %i)\r\n",frameNumber);
        long currentFilePos=ftell(io);
        long currentHelpPos=0;

        if(helpFile)
                currentHelpPos=ftell(helpFile);
        long newFilePos=currentFilePos;

        // readonly stream
        if(currentFrameNumber!=frameNumber) {
                // reposition
                if(frameNumber==0) {
                        // set to beginning
                        fseek(io,0,SEEK_SET);
                        if(helpFile)
                                fseek(helpFile,0, SEEK_SET);
                        atFileStart = true;
                        currentFrameNumber=0; // I-frame always true
                        return true;
                }
                else {
                        int auSize = sizeof(AU) - sizeof(u8 *);
                        int tmp=0;
                
                        AU *au=NULL;
                        atFileStart = false;
                        if(currentHelpPos==0) {
                                readHeader();
                                u8* temp=NULL;
                                newFilePos+=this->es->getHeaders(&temp);
                                if(temp)
                                        delete[] temp;
                        }

                        while(currentFrameNumber!=frameNumber) {
                                if(writeHelpFile) {
                                        // seeking easy: load data from helpFile

                                        au = new AU();
                                
                                        //seek forward or backward
                                        
                                        if(frameNumber>currentFrameNumber) {
                                                // seek forward
                                                tmp = fread((char *) &(au->size), 1, auSize, helpFile);
                                                if(auSize!=tmp) {
                                                        // if a seek fails undo all changes to filepointers
                                                        fseek(helpFile,currentHelpPos,SEEK_SET);
                                                        fseek(io,currentFilePos,SEEK_SET);
                                                        dprintf_err("MPGStreamIO::setToFrameNumber: failed to seek forward\n");
                                                        delete au;
                                                        return false;
                                                }
                                //              dprintf_full("MPGStreamIO::setToFrameNumber: cur=%i new=%i newFP=%li addedAUSize=%i\n",
                                //                      currentFrameNumber,frameNumber,newFilePos,au->size);
                                                newFilePos+=au->size;
                                                currentFrameNumber++;
                                                delete au;
                                                
                                        }
                                        else { // seek backward
                                                // go back one au entry
                                                fseek(helpFile,-auSize,SEEK_CUR);
                                                tmp = fread((char *) &(au->size), 1, auSize, helpFile);
                                                // now that we have read the au, reset it to
                                                // the previous position
                                                fseek(helpFile,-auSize,SEEK_CUR);

                                                if(auSize!=tmp) {
                                                        // if a seek fails undo all changes to filepointers
                                                        fseek(helpFile,currentHelpPos,SEEK_SET);
                                                        fseek(io,currentFilePos,SEEK_SET);
                                                        dprintf_err("MPGStreamIO::setToFrameNumber: failed to seek backward\n");
                                                        delete au;
                                                        return false;
                                                }
                                                newFilePos-=au->size;
                                                currentFrameNumber--;
                                                delete au;
                                        }
                                } 
                                else {
                                        // no HelpFile
                                        // we could parse vor VOP header, but we don't :-)
                                        dprintf_err("MPGStreamIO::setToFrameNumber: failed. no helpfile\n");
                                        return false;
                                }
                        } // while      

                        // if we come that far, we can reposition the movie
                        if(newFilePos>0) {
                                //helpFile should be at correct position
                                fseek(io,newFilePos,SEEK_SET);
                                currentFrameNumber=frameNumber;
                                return true;
                        }
                        else {
                                // BUG??? We tried to set to a negative position
                                dprintf_err("MPGStreamIO::setToFrameNumber: Negative new file pointer\r\n");
                                // just set to zero;
                                // set to beginning
                                fseek(io,0,SEEK_SET);
                                if(helpFile)
                                        fseek(helpFile,0, SEEK_SET);
                                atFileStart = true;
                                currentFrameNumber=0;

                                return true;
                        }
                }

        }
        else {
                // no need to reposition
                return true;
        }
        return true;
}


long MPGStreamIO::setToClosestIFrame(u32 frameNumber, bool backwards) {
        dprintf_full("MPGStreamIO::setToClosestIFrame searching direction: %s\n",backwards?"backwards":"forwards");
        if(!setToFrameNumber(frameNumber))
                return (-1);
        
        
        if(frameNumber==0 || es->isAudioStream()) {
          dprintf_full("MPGStreamIO::setToClosestIFrame returning %u (%s stream)\n",
                       frameNumber, es->isAudioStream() ? "audio" : "video");
          return frameNumber;
        }

        long currentFilePos=ftell(io);
        long currentHelpPos=0;
        long storedFrameNumber = currentFrameNumber;
        int auSize = sizeof(AU) - sizeof(u8 *);
        int tmp=0;
        AU au;

        if(helpFile)
                currentHelpPos=ftell(helpFile);

        long newFilePos=currentFilePos;
        bool firstFrame=true;

        // get the AU for the next read Frame call
        tmp = fread((char *) &(au.size), 1, auSize, helpFile);
        if (auSize==tmp) {
                newFilePos+=au.size;
        } else {
                //FIXME: maybe we have probs on very last frame :(
                state=STREAMERR;
        }

        while ((currentFrameNumber>=0) && (currentFrameNumber <= es->getNumberOfMediaSamples())) {
                if (backwards || firstFrame) {
                fseek(helpFile, -auSize, SEEK_CUR);
                }
                tmp = fread((char *) &(au.size), 1, auSize, helpFile);

                if(auSize!=tmp) {
                        // if a seek fails undo all changes to filepointers
                        fseek(helpFile,currentHelpPos,SEEK_SET);
                        fseek(io,currentFilePos,SEEK_SET);
                        currentFrameNumber = storedFrameNumber;
                        dprintf_err("MPGStreamIO::setToClosestIFrame: failed to set to I-frame\n");
                        return currentFrameNumber;
                }
                dprintf_full("frame %i type %s CTS %i\n",currentFrameNumber,Frame::VOPTypeToChar((Frame::VOP_TYPE)au.frameType),au.cts);
                if (backwards) {
                        fseek(helpFile,-auSize,SEEK_CUR);
                        newFilePos -= au.size;
                }
                if (!backwards && !firstFrame) {
                        newFilePos += au.size;
                }
                firstFrame=false;

                if(au.frameType==(u32)Frame::I_VOP
                   || au.frameType == (u32) Frame::HEADER_VOP) {
                        dprintf_full("MPGStreamIO::setToClosestIFrame: found %s at frame %i\n",
                                     Frame::VOPTypeToChar((Frame::VOP_TYPE)au.frameType), currentFrameNumber);
                        if (!backwards) { //go back to actual frame
                                newFilePos -= au.size;
                                fseek(helpFile,-auSize,SEEK_CUR);                               
                        }
                        // point to last read AU in MPGStream
                        fseek(io,newFilePos,SEEK_SET);
                        return currentFrameNumber;
                }
                if (backwards)
                        currentFrameNumber--;
                else
                        currentFrameNumber++;                   
        }


        //error: reset to beginning or end
        dprintf_err("MPGStreamIO::setToClosestIFrame() FAILED, currentFrameNumber = %u, nMediaSamples = %u "
                    "repositioning to %s\n",
                    currentFrameNumber, es->getNumberOfMediaSamples(),
                    backwards ? "START" : "END");
        if (backwards) {
                fseek(io,0,SEEK_SET);
                if(helpFile)
                        fseek(helpFile,0, SEEK_SET);
                atFileStart = true;
                currentFrameNumber=0;
        } else {
                fseek(io,0,SEEK_END);
                if(helpFile)
                        fseek(helpFile,0, SEEK_END);
                atFileStart = false;
                currentFrameNumber=es->getNumberOfMediaSamples();
                close(true);
                state=STREAMEOF;
        }
        return currentFrameNumber;
}

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