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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ffMP4IO.cpp

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

#include "ffMP4IO.hpp"
#include "CompressedVideoFrame.hpp"
#include "CompressedAudioFrame.hpp"
#include "Frame.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"

/***************************************************************/
ffMP4IO::ffMP4IO(ESInfo * esi, const char *mp4File, bool write) {
        es = esi;
        state = CLOSED;
        input = new char[strlen(mp4File) + 1];
        strcpy(input, mp4File);
        writeOnly = write;
        DTS = 0;
        currentFrameNumber = 0;
        endFrameNumber = 0;
        priofp = NULL;
  ic=NULL;

        ap = &ap1;
        if (es->isVisualStream()) { //set up timely distribution priority table
                tableSize = (int)ceil(((VideoESInfo*)es)->getFPS());
                int maxdepth=(int)((log((double)tableSize)/log(2.0)) + 1);

                dprintf_full("ffMP4IO:  timelyDistTable: calculating maxdepth %i for patSize %i (=fps)\n", maxdepth,tableSize);
                int actpos=tableSize;  //pseudo-global helper var
                for (int i=0; i<maxdepth; i++){
                        patSplit(prioTable,tableSize,i,&actpos);
                }

#ifdef VITOOKI_DEBUG
                dprintf_full("ffMP4IO:  timelyDistTable:   ");
                printPat(prioTable,tableSize);
#endif
        }
}


/***************************************************************/
ffMP4IO::~ffMP4IO() {
        delete[] input;
        close();
        //      dfclose(fp);
        if(priofp)
                fclose(priofp);
}


void ffMP4IO::printPat(int *pat, int len) {
        int i;
        for (i=0; i<len; i++) {
                if (pat[i] > -1)
                        printf("%2i-", pat[i]);
                else 
                        printf("..-");
        }
        printf("\n");
}



/***************************************************************/
int ffMP4IO::patSplitRec(int *pat, int len, int actdepth, int maxdepth, int gowhere, int *actpos) {
        int half=len/2;
        int *middle = &pat[half];
        int ret;
        
        //      printf("depth %i (of %i) pos %i len %i left %i right %i --> ",actdepth,maxdepth,*actpos,len,half,len-half);
        //printPat(pat,len,-1,0);

        if (actdepth < maxdepth) {
                if (gowhere) {
                        ret = patSplitRec(pat, half, actdepth+1, maxdepth, gowhere,actpos);
                        if (ret == 0)
                                ret = patSplitRec(pat+half,len-half, actdepth+1, maxdepth, gowhere,actpos);
                        return ret;
                } else {
                        ret = patSplitRec(pat+half,len-half, actdepth+1, maxdepth, gowhere,actpos);
                        if (ret == 0)
                                ret = patSplitRec(pat, half, actdepth+1, maxdepth, gowhere,actpos);
                        return ret;
                }
        } else {
                if (*middle == -1) {
                        *middle = (*actpos)--;
                        return 1;
                } else {
                        //      printf("FULL\n"); 
                        return 0;
                }
        }

}


/***************************************************************/
void ffMP4IO::patSplit(int *pat, int len, int maxdepth, int *actpos) {
        int i=1, j=1;

        if (*actpos == len) { //init
                for (int k=0; k<len;k++)
                        pat[k]=-1;
                patSplitRec(pat, len, 0, 0, 0, actpos);
        }

        while ((i!=0) || (j!=0))  {
                //              printf(">>>next node RIGHT\n");
                //printPat(pat,len);
                i = patSplitRec(pat, len, 0, maxdepth, 1, actpos);
                //              printf(">>>next node LEFT \n");
                //printPat(pat,len);
                j = patSplitRec(pat, len, 0, maxdepth, 0, actpos);
        }
}


/***************************************************************/
Frame *ffMP4IO::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;
  }
  
  Frame *frm = NULL;
  AU *aus = new AU();
  AVPacket pkt1, *pkt = &pkt1;  
  int err;
  do {
    err = av_read_frame(ic, pkt);
                
                //dprintf_full("ffMP4IO::getFrame() av_read_frame: streamID: %i, size %i, err = %i\n",ic->streams[pkt->stream_index]->id, pkt->size, err);
    if(err != 0)
      break;

                if (pkt->size == 0)
                        dprintf_full("ffMP4IO::getFrame() ignoring empty frame...\n");
    
    if(pkt->size>0 && ic->streams[pkt->stream_index]->id != streamID)
      av_free_packet(pkt);
    
  } while(ic->streams[pkt->stream_index]->id != streamID || (pkt->size == 0));
  
        
                if (!err)
                dprintf_full("ffMP4IO::getFrame() av_read_frame: streamID = %d, size = %d, pts = %u, dts = %u, dur = %d\n",
                                                 pkt->stream_index, pkt->size, (u32) pkt->pts, (u32) pkt->dts, pkt->duration);
        

  if(pkt->size==0) {
    dprintf_err("ffMP4IO::getFrame: Read empty packet (ret %i) (-->EOF!?)\n",err);
    delete aus;
                //    if(err==AVERROR_UNKNOWN) //EOF
                state = STREAMEOF;
    return NULL;
  }

  aus->size = pkt->size;
  //aus->sampleFlags = ;
        aus->cts = DTS;                 //XXX for the time being
        aus->dts = DTS;
  
  if(es->getCodecID() == CODEC_ID_MPEG4 || es->getCodecID() == CODEC_ID_MSMPEG4V1 ||
                 es->getCodecID() == CODEC_ID_MSMPEG4V2 || es->getCodecID() == CODEC_ID_MSMPEG4V3 ||
                 es->getCodecID() == CODEC_ID_MPEG1VIDEO
                 || es->getCodecID() == CODEC_ID_MPEG2VIDEO || es->getCodecID() == CODEC_ID_THEORA) {
    DTS += es->getVOPTimeIncrement();
  } else {
                if (es->getVOPTimeIncrement() == 1 ) //there was a zero number of samples in ffMP4ContainerFile
                        DTS += (1152*es->getMediaTimeScale())/((AudioESInfo *)es)->getSampleRate(); /* for MP3 ONLY */ 
                else
                        DTS += es->getVOPTimeIncrement();
        }
  
  aus->duration = es->getVOPTimeIncrement();    //XXX currently true only for video 
  
  switch(err) {
  case 0 : 
    aus->err = SA_OK;
    break;
  case AVERROR_NOMEM :
  case AVERROR_UNKNOWN :                        //this is what av_read... returns when EOF is reached.
    aus->err = SA_EOF;
    state = STREAMEOF;
    delete aus;
    return NULL;
  case AVERROR_IO :
  case AVERROR_NUMEXPECTED :
  case AVERROR_INVALIDDATA :
  case AVERROR_NOFMT :
  default :
    aus->err = SA_Error;
  }
  
  
  // has to do deep-copy, otherwise collision with MP4lib mem handler
  aus->payload = new u8[aus->size];
  //memcpy(aus->payload, (*(au)), aus->size);
  memcpy(aus->payload, pkt->data, aus->size);
  
  //Packet pkt no longer needed so free it
  av_free_packet(pkt);
  if(es->isVisualStream())              
    frm = new CompressedVideoFrame(Frame::NN_VOP, ((VideoESInfo*)es)->getWidth(), 
                                                                                                                                         ((VideoESInfo*)es)->getHeight());
  else if(es->isAudioStream())
    frm=new CompressedAudioFrame(Frame::NN_VOP);
  else //hack for any other stream type
                frm = new CompressedVideoFrame(Frame::NN_VOP,0,0);
  
  if (!frm->setAU(aus)) { //automatically detects frame type
    dfprintf_err(fp, "Failed to set AU at frame?");
  }
  frm->setMediaTimeScale(es->getMediaTimeScale());
        frm->setStreamID(pkt->stream_index);
        frm->setCodecID(es->getCodecID());

  if (!priofp) { //no prio-File given, use TIMELY DISTRIBUTION
    if (es->isVisualStream() && (frm->getType() == Frame::B_VOP)) {
                        frm->getAU()->prio = prioTable[currentFrameNumber % tableSize];
    }   else // reference frames or AudioFrames
      frm->getAU()->prio = IO_NETWORK_HIGHEST_PRIORITY; //highest priority is 0
  } else { //parse given prio-File
    u32 fno=0;
    char *tmp = new char[MAX_STR_LEN];
    fgets(tmp,MAX_STR_LEN,priofp);
    dprintf_full("READING %s\n",tmp);
    int ret = sscanf(tmp,"Prio %i Frame %i",(int*)&frm->getAU()->prio, &fno);
    if ( (ret <= 0) || feof(priofp)) {
      dprintf_err("ffMP4IO::getFrame: FATAL: parse error or EOF of prio-File! switching back to "
                                                                        "TIMELY DISTRIBUTION!\n");
      fclose(priofp);
      priofp = NULL;
    } else {
      if (currentFrameNumber != fno) {
                                dprintf_err("ffMP4IO::getFrame: FATAL: prio-File framenr %i doesnt match expected %i!"
                                                                                " switching back to TIMELY DISTRIBUTION!\n", fno, currentFrameNumber);
                                fclose(priofp);
                                priofp = NULL;
      } else 
                                if ((frm->getType() == Frame::I_VOP) || (frm->getType() == Frame::P_VOP))
                                        assert(frm->getAU()->prio == 0);
    }
        delete [] tmp;
  }
        dprintf_full("ffMP4IO::getFrame %5i: (%p, AU %p) setting  VOP type %s TS %i prio %i size %i  Duration %i\n",
                                                         currentFrameNumber, frm, frm->getAU(), Frame::VOPTypeToChar(frm->getType()),frm->getAU()->dts,
                                                         frm->getAU()->prio, aus->size, aus->duration); 
  
  currentFrameNumber++;
  framesSeen++;
  
#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif
  
  return frm;
}


/***************************************************************/
bool ffMP4IO::open() {
        dprintf_full("ffMP4IO::open()\r\n");
        if(!writeOnly)
                return openForReading();
        return openForWriting();
}


/***************************************************************/
IO::State ffMP4IO::play(double prefetchTime) {

        dprintf_full("ffMP4IO::play prefetch %f (old state %i)\n",prefetchTime,state);

        if (state==CLOSED) {
                open();
                return state;
        } else
                if ( (state==PAUSED) || (state==MUTED) ) 
                        setState(OPEN);
                else {
                        dprintf_err("ffMP4IO::play tried to OPEN from state %i\n",state);
                        return state;
                }
        return state;
}


/***************************************************************/
bool ffMP4IO::openForReading() {
        state = OPENING;
        int err;
        AVInputFormat *informat = NULL;
        
        dprintf_full("ffMP4IO::openForReading : input is %s\n", input);
        if (strlen(input)==0)   { //no Input given, assume video4linux
                
                memset(ap, 0, sizeof(*ap));
                if (es->isVisualStream())       {
                        dprintf_full("ffMP4IO::openForReading : using video4linux as input: VIDEO\n"); 
                        //                      ap->frame_rate = 25;
                        ap->width = 720;
                        ap->height = 576;

                        informat = av_find_input_format("video4linux");
                        ap->device  = NULL;
                        ap->channel = 0;
                        ap->standard = "ntsc";
                }
                else if (es->isAudioStream())   {
                        dprintf_full("ffMP4IO::openForReading : using audio grabbing as input: AUDIO\n"); 
                        ap->sample_rate = 44100;
                        ap->channels = 2;
                        informat = av_find_input_format("audio_device");
                }
                else 
                        dprintf_err("ffMP4IO::openForReading : Video 4 Linux: Unknown stream type!\n"); 
        }
        
        informat=NULL;
        err = av_open_input_file(&ic, input, informat, 0, ap);
        if(err < 0) {
                //HACK FOR DVB-HTTP STREAM: assume&force mpeg
                informat = av_find_input_format("mpeg");
                dprintf_full("informat is %p\n",informat);
                
                err = av_open_input_file(&ic, input, informat, 0, ap);
                if(err < 0) {
                        dprintf_full("ffMP4IO::openForReading : Error in opening file!! ffmpeg error %i\n",err);
                        state = CLOSED;
                        return false;
                }
        }
        dprintf_full("ffMP4IO::openForReading : av_open_input_file %s is ok\n", input);

        //If not enough info to get the stream parameters, we decode the
        //first frames to get it. (used in cases when file has no headers eg. mpeg1)
#ifndef WIN32   //This gives error on windows in case of audio
        err = av_find_stream_info(ic);
        if (err < 0) {
                fprintf(stderr, "%s: could not find codec parameters\n", input);
                state = CLOSED;
                return false;
        }
#endif


        streamID = es->getStreamId();
        char *tmp = new char[MAX_STR_LEN];
  strncpy(tmp,input,MAX_STR_LEN);
  if (es->isVisualStream())
                strcat(tmp,".video");
        else if (es->isAudioStream())
                strcat(tmp,".audio");
  else {
    dprintf_err("ffMP4IO::openForReading requesting streamID neither video nor audio!\n");
                delete [] tmp;
                return false;
        }
  sprintf(tmp,"%s.%i.prio",tmp,streamID);

  if ((priofp=fopen(tmp,"r")) != NULL) {
                dprintf_full("ffMP4IO::openForReading: successfully opened prio-File %s\n",tmp);
        } else {
                dprintf_full("ffMP4IO::openForReading: prio-File %s not found. using timely distribution!\n",tmp);
        }

        state = OPEN;
        dprintf_full("ffMP4IO::openForReading :  State is open\n");
        delete [] tmp;
        return true;

}


/***************************************************************/
bool ffMP4IO::openForWriting() {
  
        return false;
}


/***************************************************************/
bool ffMP4IO::close(bool immediate) {
        if (priofp)
                fclose(priofp);
        priofp = NULL;
        if (state == CLOSED)
                return true;

        state = CLOSED;
        int err;
        if (ic)
                {
                        av_close_input_file(ic);        
                        ic = NULL;
                        
                }
        
        err = 0;                        //ASSUMING no error has occured because 
        //av_close_.... does not return anything; ISONoErr = 0 
        return err;
}


/***************************************************************/
int ffMP4IO::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 ffMP4IO::getBufferFillLevel() const {
        if (state == OPEN)
                return 50;
        else if (state == STREAMEOF)
                return -1;
        else
                return 0;
}


/***************************************************************/
bool ffMP4IO::destroy() {
        close();
        return remove(input) == 0;
}


bool ffMP4IO::setToFrameNumber(u32 frameNumber) {
        if(state!=OPEN)
                open();
        if(ic) {
                if( av_seek_frame(ic, -1, frameNumber*es->getVOPTimeIncrement()*(1000000/90000), 0) )
                        return false;
        }
        else
                return false;
        return true;
}


#endif

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