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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

isoMP4IO.cpp

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

#ifdef ISOMP4

#include "isoMP4IO.hpp"
#include "MPGFrame.hpp"
#include "Frame.hpp"
#include "ESInfo.hpp"

isoMP4IO::isoMP4IO(ESInfo * es, const char *mp4File, bool write) {
    streamInfo = es;
    state = CLOSED;
    input = new char[strlen(mp4File) + 1];
    strcpy(input, mp4File);
    writeOnly = write;
    dfinitlog(fp, "isoMP4IO", es->getStreamId());
}


isoMP4IO::~ffMP4IO() {
    delete[] input;
    close();
    dfclose(fp);
}


Frame* isoMP4IO::getFrame() {
        if (state != OPEN || writeOnly) {       // FIXME: change this when adding buffering
                return NULL;
        }
        if(this->currentFrameNumber>this->endFrameNumber && endFrameNumber!=0) {
                close(true);
                state=STREAMEOF;
                return NULL;
        }

        MPGFrame *frm = NULL;
        AU *aus = new AU();
        // returns ISOEOF if no more AUs are available
        ISOErr err = MP4TrackReaderGetNextAccessUnitWithDuration(reader, au, &aus->size,
                                                                                                                                                                                                &aus->sampleFlags,
                                                                                                                                                                                                &aus->cts,
                                                                                                                                                                                                &aus->dts,
                                                                                                                                                                                                &aus->duration);
        switch (err) {
        case ISONoErr:
                aus->err = SA_OK;
                break;
        case ISOEOF:
                aus->err = SA_EOF;
                state = STREAMEOF;
                return NULL;
        default:
                aus->err = SA_Error;
        };
        if(framesSeen==0) {
                dprintf_full("isoMP4IO::getFrame settingVOPTimeIncrement %u\n",aus->duration);
                this->streamInfo->setVOPTimeIncrement(aus->duration);
        }

        dprintf_full("isoMP4IO::getFrame: Size %i Dur %i cts %i dts %i\n", 
                                                         aus->size, aus->duration,aus->cts,aus->dts);
        // has to do deep-copy, otherwise collision with MP4lib mem handler
        aus->payload = new u8[aus->size];
        memcpy(aus->payload, (*(au)), aus->size);

        frm = new MPGFrame(Frame::NN_VOP,streamInfo->getWidth(),streamInfo->getHeight());
        currentFrameNumber++;
        framesSeen++;
        
        if (!frm->setAU(aus)) {
                dfprintf_err(fp, "isoMP4IO::getFrame: Failed to set AU at frame?");
        }
        frm->setMediaTimeScale(streamInfo->getMediaTimeScale());

        //FIXME: frame prio not set correctly yet... hack to set some timely distributed values...
        //later, this should (could) be read from an additional prio text file
        if (frm->getType() == Frame::B_VOP)
                if (currentFrameNumber%2) //timely distribution
                        frm->getAU()->prio = (int)streamInfo->getFPS()*2 
                                - currentFrameNumber % (int)streamInfo->getFPS();
                else
                        frm->getAU()->prio = currentFrameNumber % (int)streamInfo->getFPS();
        else
                frm->getAU()->prio = IO_NETWORK_HIGHEST_PRIORITY; //highest priority is 0
        
        dprintf_full("isoMP4IO::getFrame: setting  VOP type %s TS %i prio %i size %i  Duration %i\n",
                                                         Frame::VOPTypeToChar(frm->getType()),frm->getAU()->dts,frm->getAU()->prio,
                                                         aus->size, aus->duration);

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

        return frm;
}


bool isoMP4IO::open() {
        dprintf_full("isoMP4IO::open()\r\n");
        framesSeen=0;
        if(!writeOnly)
                return openForReading();
        
        return openForWriting();
}


bool isoMP4IO::openForReading() {
        state = OPENING;
        ISOErr err;
        err = ISOOpenMovieFile(&moov, input, MP4OpenMovieNormal);
        if (err != ISONoErr) {
                dfprintf_err(fp, "ISOOpenMovieFile failed\r\n");
                state = CLOSED;
                return false;
        }
        dfprintf_full(fp, "ISOOpenMovieFile is ok\r\n");
        err = ISOGetMovieTrack(moov, streamInfo->getStreamId(), &trak);
        if (err != ISONoErr) {
                dfprintf_err(fp, " ISOGetMovieTrack failed\r\n");
                state = CLOSED;
                ISODisposeMovie(moov);
                return false;
        }
        
        ISOMedia media;
        err = ISOGetTrackMedia(trak, &media);
        if (err != ISONoErr) {
                state = CLOSED;
                ISODisposeMovie(moov);
                dfprintf_err(fp, " ISOGetTrackMedia failed\r\n");
                return false;
        }
        err = ISOCreateTrackReader(trak, &reader);
        if (err != ISONoErr) {
                state = CLOSED;
                ISODisposeMovie(moov);
                dfprintf_err(fp, " ISOCreateTrackReader failed\r\n");
                return false;
        }
        err = ISONewHandle(sizeof(u32), &au);
        state = OPEN;
        return true;
}


bool isoMP4IO::openForWriting() {
  
        return false;
}


bool isoMP4IO::close(bool immediate) {
        if (state == CLOSED)
                return true;
        
        state = CLOSED;
        ISOErr err;
        err = MP4DisposeHandle(au);
        err &= MP4DisposeTrackReader(reader);
        err &= MP4DisposeMovie(moov);
        return err == ISONoErr;
}


int isoMP4IO::writeFrame(Frame * frm, ESInfo *out_es) {
#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

        return 0;
}


int isoMP4IO::getBufferFillLevel() const {
        if (state == OPEN)
                return 50;
        else if (state == STREAMEOF)
                return -1;
        else
                return 0;
}


bool isoMP4IO::destroy() {
    close();
    return remove(input) == 0;
}

#endif

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