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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

VITMuxDemuxIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       VITMuxDemuxIO.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 "VITMuxDemuxIO.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "../container/VITContainerFile.hpp"

 
VITMuxDemuxIO::VITMuxDemuxIO(ByteStream *stream) : MuxDemuxIO(stream) {
}


VITMuxDemuxIO::~VITMuxDemuxIO() {
}

int VITMuxDemuxIO::writeFrame(Frame * frm, ESInfo *out_es) {

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

        if (state != OPEN || readOnly) {
                dprintf_err("VITMuxDemuxIO::writeFrame: Stream not open (for writing?)!\n");
                return 0;
        }
        
        if (firstFrame) {               //write Container Header to stream
                firstFrame=false;

                //FOURCC
                char fourcc[5];
                strcpy(fourcc,"VIT ");
                stream->write( fourcc,4); //only write first 4 bytes, ignore \0

                //version number
                u32 version = VIT_VERSION_NUMBER;
                stream->write( &version, sizeof(version));

                //number of following (muxed) tracks
                u32 numTracks = getNumberOfConnectedBufferedIO();
                stream->write( &numTracks, sizeof(numTracks));


                //write list of streamID and CODEC_ID
                map < int, BufferedIO* >::iterator currIO;
                for(currIO=ioList.begin(); currIO != ioList.end(); currIO++) {
                        ESInfo *esi = currIO->second->getESInfo();

                        VITTrackInfo ti;
                        memset(&ti,0,sizeof(ti)); //get it empty

                        ti.streamID = currIO->first;
                        ti.codecID = esi->getCodecID();
                        ti.kbps = esi->getAvgBandwidth() / 1024;
                        ti.vopinc = esi->getVOPTimeIncrement();

                        if (esi->isVisualStream()) {
                                ti.streamType = VIT_VIDEO;
                                ti.esi.vi.fps = (u32)ceil(((VideoESInfo*)esi)->getFPS());
                                ti.esi.vi.width = (u32)((VideoESInfo*)esi)->getWidth();
                                ti.esi.vi.height = (u32)((VideoESInfo*)esi)->getHeight();
                                ti.esi.vi.aspectRatio = (float)((VideoESInfo*)esi)->getAspectRatio();

                        } else if (esi->isAudioStream()) {
                                ti.streamType = VIT_AUDIO;
                                ti.esi.ai.sampleRate = ((AudioESInfo*)esi)->getSampleRate();
                                ti.esi.ai.channels = ((AudioESInfo*)esi)->getAudioChannels();
                                //copy first two characters
                                ti.esi.ai.language[1] = ((AudioESInfo*)esi)->getLanguage()[1];
                                ti.esi.ai.language[2] = ((AudioESInfo*)esi)->getLanguage()[2];
                        }

                        dprintf_full("VITMuxDemuxIO::writeFrame: Header with streamID %i CodecID %i StreamType %i\n", 
                                                                         ti.streamID, ti.codecID, ti.streamType);
                        stream->write(&ti, sizeof(ti));
                }
                

        }

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


        VITFrameInfo fi;
        //FIXME: litte/big endian awareness is missing!!
        fi.streamID = (u32)out_es->getStreamId();
        fi.cts =  frm->getAU()->cts;
        fi.size = frm->getAU()->size;
        stream->write( &fi, sizeof(fi));

        // save the frame
        int i = stream->write(frm->getAU()->payload, frm->getAU()->size);



        framesSeen++;

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

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





Frame *VITMuxDemuxIO::getFrame() {
        if (firstFrame && (state != OPEN)) {
                dprintf_err("VITMuxDemuxIO::getFrame: opening\n");
                this->open();
        }

        if (state != OPEN || !readOnly) {
                dprintf_err("VITMuxDemuxIO::getFrame: Stream not open (for reading?) or EOF!\n");
                return 0;
        }
        
        if (firstFrame) {               //write Container Header to stream

                //HEADER parsing is not necessary, since the stream is still open from VITContainerFile!

                /*
                //jump over already parsed header and do some sanity checks
                //FOURCC
                char fourcc[5];
                stream->read( fourcc,4); //only read first 4 bytes, add \0
                fourcc[4] = '\0';
                if (strcmp(fourcc,"VIT ") != 0) {
                        dprintf_err("VITMuxDemuxIO::getFrame: stream %s is no ViTooKi VIT container file!\n",stream->getUrl());
                        close(true);
                        return NULL;
                }
                
                //version number
                u32 version;
                stream->read( &version, sizeof(version));
                if (version != VIT_VERSION_NUMBER) {
                        dprintf_err("VITMuxDemuxIO::getFrame: VIT file %s has wrong version number %i (expected %i)!\n",
                                                                        stream->getUrl(),version,VIT_VERSION_NUMBER);
                        close(true);
                        return NULL;
                }
                
                //number of following (muxed) tracks
                u32 numTracks;
                stream->read( &numTracks, sizeof(numTracks));
                dprintf_full("VITMuxDemuxIO::getFrame: VIT file contains %i elementary streams\n",numTracks);
                
                
                //jump over list of tracks
                for (u32 curr=0; curr < numTracks; curr++) {
                        
                        VITTrackInfo ti;
                        stream->read(&ti, sizeof(ti));
                        dprintf_full("VITMuxDemuxIO:getFrame Header withstreamID %i CodecID %i StreamType %i\n", 
                                                                         ti.streamID, ti.codecID, ti.streamType);
                }
                */

                firstFrame=false;
        }

        //parse frame header and then payload
        //FIXME: litte/big endian awareness is missing!!
        VITFrameInfo fi;
        int ret;
        Frame *frm = NULL;

        ret = stream->read( &fi, sizeof(fi));

        if (ret == sizeof(fi)) {
                // read the real frame
                AU *au = new AU();
                Frame::FrameType type = Frame::NN_VOP;
                
                au->size = fi.size;
                au->payload = new u8[fi.size];
                au->cts = fi.cts;
                au->dts = au->cts;

                //get the payload
                ret = stream->read(au->payload, fi.size);


                //NOTE: some things (duration, codecID, ...) have to be set in processFrame(), 
                //since here there are no ESs known yet....
                au->sampleFlags = 0;
                au->err = SA_OK;
                
                
                frm = new Frame(type);
                frm->setStreamID(fi.streamID); //give the mapping for the right BufferedIO/ESInfo
                                               // later in processReadFrame..
                frm->setAU(au);
                
                
                framesSeen++;
                currentFrameNumber++;
                dprintf_full("VITMuxDemuxIO::getFrame: stream offset %llu, CTS %i,size %i, streamID %i\n",
                             stream->tell(), fi.cts, fi.size, fi.streamID);
        }


        if (ret == -1) {
#ifndef WINCE
                dprintf_err("VitMuxDemuxIO::getFrame failed to read full frame: ferror %i\n",ret);
                perror("VitMuxDemuxIO::getFrame failed to read full frame");
#endif
                state = STREAMERR;
                return NULL;
        }
        else if (ret == 0) {
                dprintf_full("VITMuxDemuxIO::getFrame: STREAMEOF reached\n");
                state = STREAMEOF;
                return NULL;
        }
        


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

  return frm;
}

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