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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MuxDemuxIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MuxDemuxIO.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 "MuxDemuxIO.hpp"
#include "CompressedVideoFrame.hpp"
#include "CompressedAudioFrame.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "IO.hpp"



MuxDemuxIO::MuxDemuxIO(ByteStream *stream) : IO() {
        assert(stream);
        this->stream = stream;
        readOnly = stream->isReadOnly();
        state = CLOSED;
        currentFrameNumber=0;
        firstFrame=true;
        mutex = new VMutex();
        mutex->release();
        ioList.clear();
        dprintf_full("MuxDemuxIO for %s constructed!\n",stream->getUrl());

}


MuxDemuxIO::~MuxDemuxIO() {
  if (state != CLOSED)
                close();
        if (stream)
                delete stream;
        delete mutex;
}

bool MuxDemuxIO::open() {       
        dprintf_full("MuxDemuxIO::open(), working with %i BufferedIOs \n",ioList.size());
        assert(stream);
        if(state==OPEN)
                return true;

        bool ret = false;
        state = OPENING;  

        ret = stream->open();
        
        if (ret)
                        state = OPEN;
        else
                state = CLOSED;

        currentFrameNumber=0;
        framesSeen=0;

        return ret;
}


bool MuxDemuxIO::close(bool immediate) {
  state = CLOSING;
        stream->close();
        state = CLOSED;
  return true;
}


bool MuxDemuxIO::destroy() {
    this->close();
    return true;
}


int MuxDemuxIO::writeFrame(Frame * frm, ESInfo *out_es) {
        dprintf_full("MuxDemuxIO::writeFrame %p\n",frm);

        if (state != OPEN)
                this->open();

        if (state != OPEN) {
                dprintf_err("MuxDemuxIO::writeFrame: Stream not open!\n");
                return 0;
        }
        
        if (firstFrame) {
                firstFrame=false;
                //write Container Header to file
        }

        dprintf_full("MuxDemuxIO::writeFrame: writing frame CTS %i size %i from streamID %lli to container\n", 
                                                         frm->getAU()->cts, frm->getAU()->size, out_es->getStreamId());

        // forwarding the frame to container file


        framesSeen++;

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

        return true;
}



Frame *MuxDemuxIO::getFrame() {
        if (!readOnly || state != OPEN)
                return NULL;
        
#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif

  return NULL;
}


bool MuxDemuxIO::addBufferedIO(int streamID, BufferedIO *bufIO) {
        mutex->lock();

        dprintf_full("MuxDemuxIO::addBufferedIO with streamID %i, already %i elems in list\n",streamID,ioList.size());

        if (!readOnly && !firstFrame) {
                dprintf_err("MuxDemuxIO::addBufferedIO but container HEADER already written!!!!\n");
                ::exit(1);
        }

        //FIXME: check for double streamIDs!
        ioList[streamID] = bufIO;

        mutex->release();

        return true;
}


bool MuxDemuxIO::removeBufferedIO(int streamID, BufferedIO *bufIO) {
        mutex->lock();

        dprintf_full("MuxDemuxIO::removeBufferedIO with streamID %i\n",streamID);
        ioList.erase(streamID);
        
        mutex->release();

        return true;
}


int MuxDemuxIO::getNumberOfConnectedBufferedIO() {
        int size;

        //FIXME: no locks, since it's already locked in processFrame
        //      mutex->lock();
        size=ioList.size(); 
                //      mutex->release();

        return size;

}


void MuxDemuxIO::processFrame() {
        mutex->lock();

        if (readOnly)
                processReadFrame();
        else
                processWriteFrame();            

        mutex->release();
}


void MuxDemuxIO::processReadFrame() {
        map < int, BufferedIO* >::iterator currIO;
        int bufFillMin = 999999;

        Frame *frm = getFrame();

        if (!frm) {
                dprintf_full("MuxDemuxIO::processReadFrame: no more frames left, EOF or major problems ;)\n");
                return;
        }

        BufferedIO *bufio = ioList[frm->getStreamID()];

        if (!bufio) { //no handler installed for this streamID
                //THIS IS DEFINITELY STUPID IN STL (by trying to read it, its created to the map!)
                ioList.erase(frm->getStreamID());
                
                dprintf_full("MuxDemuxIO::processReadFrame: got next frame for UNINITIALIZED streamID %i CTS %i, ignoring...\n",
                                                         frm->getStreamID(), frm->getAU()->cts);

                delete frm;
        } else {

                ESInfo *esi = bufio->getESInfo();

                //put frm into real type
                Frame *realfrm = NULL;
                if (esi->isVisualStream())              
                        realfrm = new CompressedVideoFrame(Frame::NN_VOP, ((VideoESInfo*)esi)->getWidth(), 
                                                                                                                                                                 ((VideoESInfo*)esi)->getHeight());
                else if(esi->isAudioStream())
                        realfrm=new CompressedAudioFrame(Frame::NN_VOP);
                else //hack for any other stream type
                        realfrm = new CompressedVideoFrame(Frame::NN_VOP,0,0);
                
                
                //take over old values
                realfrm->setStreamID(frm->getStreamID());
                realfrm->setAU(frm->getAU());
                frm->unsetAU(); //to save from deletion
                delete frm;
                
                //fill new ES information
                realfrm->getAU()->duration = esi->getDuration();
                realfrm->setMediaTimeScale(esi->getMediaTimeScale());
                realfrm->setCodecID(esi->getCodecID());
                
                bufio->addToBuffer(realfrm);

                dprintf_full("MuxDemuxIO::processReadFrame: got next frame for streamID %i CTS %i type %s size %i\n",
                                                         realfrm->getStreamID(), realfrm->getAU()->cts, Frame::VOPTypeToChar(realfrm->getType()), realfrm->getAU()->size);

        }


        //check buffer fill level
        for(currIO=ioList.begin(); currIO != ioList.end(); currIO++) {
                //check, if none of the streams is closing
                if (currIO->second->getState() != OPEN)
                        return;

                //find out the minimum bufferFillLevel
                if (currIO->second->getBufferFillLevel() < bufFillMin)
                        bufFillMin = currIO->second->getBufferFillLevel();
        }
        
        //needed for good balanced muxing
        if (bufFillMin < 500) {
                dprintf_full("MuxDemuxIO::processReadFrame: STARTUP: not enough data (%i frames) in BufferedIOs....harvesting...\n",bufFillMin);
#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield();
#else
        // for windows pthread lib!
#ifndef WINCE
        sched_yield();
#else
        Sleep(0);
#endif
#endif
                processReadFrame();
        }
}



void MuxDemuxIO::processWriteFrame() {
        map < int, BufferedIO* >::iterator currIO;
        u32 lowestCTS = ~(u32)0; //make it the highest number possible
        s64 actCTS = -1;
        s64 streamID = -1;
        int bufFillMin = 999999;

        dprintf_full("MuxDemuxIO::processWriteFrame: finding next frame with lowest CTS, firstFrame is %s \n",firstFrame?"TRUE":"FALSE");

        
        for(currIO=ioList.begin(); currIO != ioList.end(); currIO++) {
                if ( (currIO->second->getState() == IO::OPEN) || (currIO->second->getState() == IO::CLOSING)) {
                        actCTS = currIO->second->nextCTSinBuf();
                        dprintf_full("MuxDemuxIO::processWriteFrame: checking  streamID %i with CTS %lli!\n",currIO->first, actCTS);
                        if ((actCTS >= 0) && (actCTS < lowestCTS)) {
                                lowestCTS = actCTS;
                                streamID = currIO->first;
                        }
                        if (firstFrame && (currIO->second->getBufferFillLevel() < bufFillMin))
                                bufFillMin = currIO->second->getBufferFillLevel();

                } else {
                        dprintf_full("MuxDemuxIO::processWriteFrame: BufferIO for streamID %lli is CLOSED!\n",streamID);
                }
        }

        if (streamID < 0) {
                dprintf_full("MuxDemuxIO::processWriteFrame: no data in any BufferedIOs....\n");
                return;
        }

        //needed for good balanced muxing (try 30 or the actual video frame rate (one second of video...)
        if ((ioList[streamID]->getState() == IO::OPEN) && firstFrame && (bufFillMin < 30)) {
                dprintf_full("MuxDemuxIO::processWriteFrame: STARTUP: not enough data in ALL BufferedIOs....harvesting...\n");
                return;
        }

        Frame *frm = ioList[streamID]->getFrame();
                                        
        if (frm) {
                dprintf_full("MuxDemuxIO::processWriteFrame: writing frame %p ES-ID %lli CTS %i type %s size %i to container\n",
                                                                 frm, streamID, frm->getAU()->cts, Frame::VOPTypeToChar(frm->getType()), frm->getAU()->size);
                                                
                //add header and write it to file
                writeFrame(frm, ioList[streamID]->getESInfo());
                
                //FIXME: this is an ugly memory leak fix... the whole crappy frame-concept should use reference counter...
                if (ioList[streamID]->getBufferFillLevel() > 0)
                        delete frm; //there are more left, so take care of memory
                else
                        frm->markForDelete(); //it's the direct DataChannel frame, so let the DC do the delete...
                
                
        } else {
                dprintf_full("MuxDemuxIO::processWriteFrame: BufferedIO for streamID %lli has no data! WHY???\n",streamID);
                assert(1==0);
        }

}

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