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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ContainerInfo.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: ContainerInfo.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 "ContainerInfo.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "BifsESInfo.hpp"
#include "ObjectDescriptorESInfo.hpp"
#include "global.hpp"
#include "io/IOCreator.hpp"

#include <stdio.h>
#ifndef WINCE
#include <sys/types.h>
#include <sys/stat.h>
#include <iostream>
#endif //wince
#ifndef WIN32
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
#ifndef WINCE
#include <sys/stat.h>
#include <fcntl.h>
#endif //wince
#include <string.h>
#include "BitField.hpp"
#include "ReferenceCounter.hpp"


//FIXME: CacheContainerInfo
#include "cache/MetaObject.hpp"

ContainerInfo::ContainerInfo(const char *uri, const char *locFile, ContainerType ctype) : qinfo(0,5) {
        dprintf_small("ContainerInfo:: VOB local: %s   URI: %s\n", locFile, uri);
        type = ctype;
        muxDemuxIO = NULL;

        //assert(uri || locFile);
        if(uri)
                url = new Url(uri);
        else
                url=NULL;
        localFile=NULL;
        if(locFile) {
                setLocalFile(locFile); // correct / 
        }

  iodHandle = NULL;
  iodHandleSize = 0;
        metaObj=NULL;
  lastAccessTime = 0;
        usageCounter=new ReferenceCounter();
}


ContainerInfo::ContainerInfo(): qinfo(0,5)
{
        url = NULL;
        muxDemuxIO = NULL;
        metaObj=NULL;
        localFile = NULL;
        iodHandle = NULL;
        iodHandleSize = 0;
        lastAccessTime = 0;
        usageCounter=new ReferenceCounter();
        esList.clear();
}

ContainerInfo::ContainerInfo(QualityInfo & q): qinfo(q)
{
        url = NULL;
        muxDemuxIO = NULL;
        iodHandle = NULL;
        localFile = NULL;
        iodHandleSize = 0;
        lastAccessTime = 0;
        metaObj=NULL;
        usageCounter=new ReferenceCounter();
}

ContainerInfo::~ContainerInfo()
{
        dprintf_full("ContainerInfo::~ContainerInfo() %s\n",(localFile?localFile:"NULL"));
        clear();
}

void
ContainerInfo::clear()
{
        if (iodHandle)
                delete[] iodHandle;

        if (url)
                delete url;

        if(localFile)
                delete[] localFile;

        if (muxDemuxIO)
                delete muxDemuxIO;
        
        iodHandle = NULL;
        url = NULL;
        localFile=NULL;
        iodHandleSize = 0;
        // also delete all es
        list < ESInfo * >::iterator li = esList.begin();
        while (!esList.empty()) {
                li = esList.begin();
                dprintf_full("ContainerInfo::clear() going to delete ESinfo id %llu\n",(*li)->getStreamId());
                delete(*li);
                esList.pop_front();
        }
        if(usageCounter &&!usageCounter->deactivateWhenUsage(0)) {
                dprintf_err("ContainerInfo::clear: destroying ContainerInfo which is still in use!\n");
        }
        if(usageCounter)
                delete usageCounter;
}

void ContainerInfo::setIODHandle(u8 * iod, u32 iodSize)
{
        if (iod && iodSize > 0) {
                if (iodHandle)
            delete[] iodHandle;
                iodHandle = new u8[iodSize];
                memcpy((char *) iodHandle, (char *) iod, iodSize);
                iodHandleSize = iodSize;
        } else {
                dprintf_err("Illegal parameters in ContainerInfo::setIODHandle\n");
        }
}



bool ContainerInfo::saveToCfgFile(char *indexName)
{
        // check if the entry is valid 
  if (!url || (iodHandleSize>0 && !iodHandle) )
                return false;
        // either localfile or url must be set
        if(!localFile && !url)
                return false;
        FILE* file=fopen(indexName,"wb");
        char *oneLine = new char[4096];
        oneLine[0] = 0;
        u32 len = 0;
        if (file) {

                // Format:  version magic number
                //                              url <space>  \r\n
                //                      localFile or NULL \r\n
                //          iodHandleSize <space> iodHandle <space> <nrES> <space> \r\n
                // each ES entry has the following format (one single Line, entries within
                // line separated by <space>):
                //    streamId handlerType encodedDecoderConfig objectType streamType
                //      bufferSize [<fileName_of_input>||null] \r\n
        
                if(url) {
                        sprintf(oneLine, "%i \r\n%s \r\n%s \r\n%i ", MP4CONF_VERSION,(localFile?localFile:"NULL"), url->toString(), iodHandleSize);     
                }
                else { //FIXME: this is dead code
                        sprintf(oneLine, "%i \r\n%s \r\nNULL \r\n%i ", MP4CONF_VERSION,localFile, iodHandleSize);
                }
                len = strlen(oneLine);
                if (len != fwrite(oneLine,1, len, file)) {
                        fclose(file);
#ifndef WINCE
                        ::remove(indexName);
#else
                        DeleteFile((LPCTSTR)indexName);
#endif
                        delete [] oneLine;
                        return false;
                }
                // now write the IOD

                if (iodHandle && iodHandleSize>0 && (iodHandleSize !=
                                                                                                                                                                 fwrite(iodHandle, 1, iodHandleSize,file)) ) {
                        fclose(file);
#ifndef WINCE
                        ::remove(indexName);
#else
                        DeleteFile((LPCTSTR)indexName);
#endif
                        delete [] oneLine;
                        return false;
                }
                oneLine[0] = 0;
                sprintf(oneLine, " %i \r\n", esList.size());
                len = strlen(oneLine);
                if (len != fwrite(oneLine, 1, len, file)) {
                        fclose(file);
#ifndef WINCE
                        ::remove(indexName);
#else
                        DeleteFile((LPCTSTR)indexName);
#endif
                        delete [] oneLine;
                        return false;
                }
                // now start to write the ES
                u32 tid = 0;
                u32 handlerType = 0;
                const u8 *decoderConfig = NULL;
                u32 decConfSize = 0;
                u32 objectType = 0;
                u32 streamType = 0;
                u32 bufferSize = 0;
                u32 width = 0;
                u32 height = 0;
                u32 avg = 0;
                u32 max = 0;
                u32 time = 0;
                u64 dur = 0;
                u32 size = 0;
                u32 ticks = 0;
                char *input = NULL;
                u32 hasColor= true;
                u32 isComplete = true;
                u32 codecId= 0;
                float quality= 0.0;
                float aspectRatio=0;
                u32 gop_size=0; 
                u32 bFrames=0;
                u32 audioSampleRate=0;
                u32 numChannels=2;
                bool hasInput = true;
                char* stat=NULL;
                float bframesize=0.0;
                u32 staticFramePattern=0;

                list < ESInfo * >::iterator li = esList.begin();
                for (int i = 0; i < (int) esList.size(); i++) {
                        tid = (*li)->getStreamId();
                        streamType = (*li)->getStreamType();
                        handlerType = (*li)->getHandlerType();
                        decoderConfig = (*li)->getEncodedDecoderConfig();
                        decConfSize = strlen((const char *) decoderConfig);
                        objectType = (*li)->getObjectType();
                
                        bufferSize = (*li)->getBufferSize();
                        if(handlerType==MP4VisualHandlerType) {
                                width = ((VideoESInfo*)(*li))->getWidth();
                                height = ((VideoESInfo*)(*li))->getHeight();
                                hasColor= ( ((VideoESInfo*)(*li))->getHasColor() ? 1 : 0);
                                aspectRatio= ((VideoESInfo*)(*li))->getAspectRatio();
                                gop_size=((VideoESInfo*)(*li))->getGOP_size();
                                bFrames=((VideoESInfo*)(*li))->getNum_B_frames();
                                bframesize=((VideoESInfo*)(*li))->getAvgBFrameSize();
                                staticFramePattern=(((VideoESInfo*)(*li))->hasStaticFramePattern()? 1 : 0);
                        }
                        else {
                                width=0;
                                height=0;
                                hasColor=true;
                        }
                        if(handlerType==MP4AudioHandlerType) {
                                audioSampleRate=((AudioESInfo*)(*li))->getSampleRate();
                                numChannels=((AudioESInfo*)(*li))->getAudioChannels();
                        }
                        else {
                                audioSampleRate=0;
                                numChannels=0;
                        }
                        avg = (*li)->getAvgBandwidth();
                        max = (*li)->getMaxBandwidth();
                        time = (*li)->getMediaTimeScale();
                        dur = (*li)->getDuration();
                        size = (*li)->getOrigMediaSize();
                        ticks = (*li)->getVOPTimeIncrement();
                        input = (char*) (*li)->getInput();

                        isComplete = ( (*li)->getCompleteState() ? 1 : 0);
                        codecId= (u32) (*li)->getCodecID();
                        quality= (*li)->getStreamQuality();
                        hasInput = true;
                        if (!input) {
                                input = new char[5];
                                strcpy(input, "NULL");
                                hasInput = false;
                        }
                
                        if((*li)->getFrameStatistic() && 
                                 (*li)->getFrameStatistic()->getSize()>0) {
                                stat=(*li)->getFrameStatistic()->toAsciiString();
                        }
                        else {
                                stat=new char[5];
                                strcpy(stat,"NULL");
                        }
                        dprintf_small("Wrote:%u %u %u %s %u %u %u %s \r\n", tid,
                                                                                handlerType, decConfSize, decoderConfig,
                                                                                objectType, streamType, bufferSize, input);
                        ++li;           // increase list iterator
                        // streamId handlerType decConfSize encodedDecoderConfig objectType
                        // streamType bufferSize width height avg max time dur mediasize .... [<fileName_of_input>||null] \r\n
                        oneLine[0] = 0;

                        // dur is 64 bit -> split in two 32 bit valus -> higher 32 bit first
                        sprintf(oneLine," %u %u %u %s %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %6.6f %6.6f %u %u %f %u %u %u %s \r\n",
                                                        tid, handlerType, decConfSize, decoderConfig,
                                                        objectType, streamType, bufferSize, width, height, avg,
                                                        max, time, (u32) (dur >> 32), (u32) dur, size,
                                                        ticks, hasColor, isComplete, codecId, quality, aspectRatio, 
                                                        gop_size,bFrames,bframesize,staticFramePattern,
                                                        audioSampleRate, numChannels,input);
                        len = strlen(oneLine);
                
                        if (len != fwrite(oneLine, 1, len, file)) {
                                fclose(file);
#ifndef WINCE
                        ::remove(indexName);
#else
                        DeleteFile((LPCTSTR)indexName);
#endif
                                delete [] oneLine;
                                return false;
                        }
                        fprintf(file,"%s \r\n",stat);
                        delete stat;
                        stat=NULL;
                        if (!hasInput) {
                                delete input;
                                input = NULL;
                        }
                }
                fclose(file);
                delete [] oneLine;
                return true;
        } else {
                delete [] oneLine;
                return false;
        }
}


bool ContainerInfo::loadFromCfgFile(char *indexName) {
        FILE *file = fopen(indexName, "rb");
        if (!file)
                return false;

  char *line = new char[MAX_BUFFER_SIZE];
        int versionMagic=0;
        // get version number
        line[0] = 0;
        fgets(line, MAX_BUFFER_SIZE, file);
        sscanf(line,"%i",&versionMagic);
        if(versionMagic!=MP4CONF_VERSION) {
                dprintf_err("Detected old mp4.conf file\n");
                fclose(file);
                delete [] line;
                return false;
        }
  // line contains localFile \r\n
  line[0] = 0;
        fgets(line, MAX_BUFFER_SIZE, file);
        if(localFile) {
                delete[] localFile;
                localFile=NULL;
        }
        if(strlen(line)>3) {
                if(strstr(line,"NULL")) {
                        localFile=NULL;
                }
                else {
                        localFile=new char[strlen(line)+1];
                        strcpy(localFile,line);
                }
        }

  dprintf_full("ContainerInfo::loadFromCfgFile: EMPTY Mp4StreamInfo object created\r\n");
        //2nd line: URL or NULL
        line[0] = 0;
  fgets(line, MAX_BUFFER_SIZE, file);
  if (strlen(line) < 4) {
                fclose(file);
                delete [] line;
                return false;
  }
        if(url) {
                delete url;
        }
  url = new Url(line);
  if (!url->toString()) {
                clear();
                fclose(file);
                delete [] line;
                return false;
  }     
        // 3rd line: iodHandleSize <space> iodHandle <space> <nrES> <space> \r\n

        //read iodHandleSize
        int pos = 0;
        int ch = 0;
        bool space = false;
        while (!space) {
                ch = fgetc(file);
                if (ch < 0) {
            clear();
                fclose(file);
                delete [] line;
            return false;
                }
                line[pos] = (char) ch;
                if (line[pos] == ' ')
            space = true;
                pos++;
        }
        // pos contains the number of chars read
        line[pos] = 0;
        iodHandleSize = atoi(line);
        if (iodHandleSize < 0) {
                dprintf_err("ContainerInfo: illegal iodHandleSize\n");
                clear();
                fclose(file);
                delete [] line;
                return false;
        }
        if(iodHandleSize>0) {
                iodHandle = new u8[iodHandleSize];
                iodHandle[0] = 0;
        }
        else
                iodHandle=NULL;

        if (iodHandle && 
                        (iodHandleSize) != fread(iodHandle, 1, iodHandleSize, file)) {
                dprintf_err("ContainerInfo: Failed to read IOD\n");
                clear();
                fclose(file);
                delete [] line;
                return false;
        }

        // now read the number of ES
        line[0] = 0;
        fgets(line, MAX_BUFFER_SIZE, file);
        if (strlen(line) < 4) {
                dprintf_err("ContainerInfo: failed to read 2nd Line\n");
                clear();
                fclose(file);
                delete [] line;
                return false;
        }
        int nrEs = -1;
        if (1 != sscanf(line, " %i", &nrEs)) {
                dprintf_err("ContainerInfo: failed to read nrES\n");
                clear();
                fclose(file);
                return false;
        }
        if (nrEs < 0) {
                dprintf_err("ContainerInfo: illegal nrES\n");
                clear();
                fclose(file);
                delete [] line;
                return false;
        }
        // read the ES entries
        u32 size = 0;
        for (int i = 0; i < nrEs; i++) {
                line[0] = 0;
                fgets(line, MAX_BUFFER_SIZE, file);
                if (strlen(line) == 0) {
                        clear();
                        fclose(file);
                        delete [] line;
                        return false;
                }
                ESInfo *entry = parseES(line);
                if (!entry) {
                        dprintf_err("ContainerInfo: failed to read ES %i\n", i);
                        clear();
                        fclose(file);
                        delete [] line;
                        return false;
                }
                u32 sample=entry->getNumberOfMediaSamples();
                if(sample==0) {
                        fgets(line, MAX_BUFFER_SIZE, file); // read NULL string
                }
                else {
                        char* data=new char[sample+5];
                        fgets(data,sample+5,file);
                        if(strcmp(data,"NULL")!=0) {
                                data[sample]='\0';
                                entry->setFrameStatistic(BitField::fromAsciiString(data));
                        }
                        delete[] data;
                }
                addESInfo(entry);
                size += entry->getOrigMediaSize();
        }
        qinfo.steps[0]->size = size;
        fclose(file);
        delete [] line;
        return true;
}


ESInfo *ContainerInfo::parseES(char *line) {

        ESInfo *result=NULL;
        u32 tid;
        u32 handlerType;
        u8 *decoderConfig=NULL;
        u32 decConfSize;
        u32 objectType;
        u32 streamType;
        u32 bufferSize;
        u32 width;
        u32 height;
        u32 avg;
        u32 max;
        u32 time;
        u64 dur;
        u32 dl, dh, size;
        u32 tickInc = 0;
        u32 hasColor=1;
        u32 codecId;
        u32 gop_size=0;
        u32 numBFrames=0;
        float quality;
        float aspectRatio=1.0;
        u32 audioSampleRate;
        u32 numChannels;
        bool bColor;
        bool bIsComplete;
        u32 staticFramePattern=0;
        bool bStaticFramePattern=false;
        float bframesize=0.0;
        u32 isComplete=1;
        char *fileName = new char[4096];

        // streamId handlerType decConfSize encodedDecoderConfig objectType
        // streamType bufferSize width height avg max timescale duration [<fileName_of_input>||null] \r\n
        if (3 != sscanf(line, "%u %u %u", &tid, &handlerType, &decConfSize)) {
                dprintf_err("ContainerInfo::parseES1: Invalid or old ES File! Delete your demux dir\n%s\n",line);
                delete [] fileName;
                return NULL;
        }
        decoderConfig = new u8[decConfSize + 1];
        // duration is 64 bits, read higher bits first, then lower
        if (28 != sscanf(line, "%u %u %u %s %u %u %u %u %u %u %u %u %u %u %u %u %u %u %u %f %f %u %u %f %u %u %u %s ",
                                                                         &tid, &handlerType, &decConfSize, decoderConfig,
                                                                         &objectType, &streamType, &bufferSize, &width, &height,
                                                                         &avg, &max, &time, &dh, &dl, &size, &tickInc, &hasColor, &isComplete, 
                                                                         &codecId, &quality, &aspectRatio, &gop_size, &numBFrames, &bframesize,&staticFramePattern,
                                                                         &audioSampleRate, &numChannels, fileName)) {
                dprintf_err("ContainerInfo::parseES2: Invalid or old ES File! Delete your demux dir\n%s\n",line);
                delete [] fileName;
                return NULL;
        }
        bStaticFramePattern= (staticFramePattern==1) ? true : false;
        bColor = (hasColor==1) ? true : false;
        bIsComplete = (isComplete==1) ? true : false;
        dur = dh;
        dur <<= 32;
        dur += dl;
        dprintf_small
                ("Read:%i %i %i %s %i %i %i %i %i %i %i %i %i %i %i %i %i %s \r\n", tid,
                 handlerType, decConfSize, decoderConfig, objectType, streamType,
                 bufferSize, width, height, avg, max, time, dh, dl, size, hasColor, isComplete,
                 fileName);
        if(time==0) {
                dprintf_err("ContainerInfo::parseES: wrong timescale in conf file!\n");
                fprintf(stderr,"ContainerInfo::parseES: wrong timescale in conf file!\n");
                time=90000;
        }
        if(handlerType==MP4VisualHandlerType) {
                result = new VideoESInfo(tid, streamType, this, tickInc, decoderConfig, objectType,
                                                                                                                 bufferSize, avg, max, time, dur, size, width, height, 
                                                                                                                 bColor, bIsComplete,(enum CodecID)codecId, quality, 
                                                                                                                 aspectRatio,gop_size,numBFrames,bStaticFramePattern,bframesize);
        }
        else if(handlerType==MP4AudioHandlerType) {
                result= new AudioESInfo(tid, streamType, this, tickInc, decoderConfig, objectType,
                                                                                                                bufferSize, avg, max, time,
                                                                                                                dur, size, bIsComplete,audioSampleRate, numChannels, 
                                                                                                                (enum CodecID)codecId, quality);
        }
        else if(handlerType==MP4SceneDescriptionHandlerType) {
                result= new BifsESInfo(tid, streamType, this, tickInc, decoderConfig, objectType,
                                                                                                         bufferSize, avg, max, time, dur, size, bIsComplete,
                                                                                                         (enum CodecID)codecId, quality);
        }
        else if(handlerType==MP4ObjectDescriptorHandlerType) {
                result= new ObjectDescriptorESInfo(tid, streamType, this, tickInc, decoderConfig, objectType,
                                                                                                                                                         bufferSize, avg, max, time, dur, size, bIsComplete,
                                                                                                                                                         (enum CodecID)codecId, quality);
        }
        else {
                dprintf_err("ContainerInfo::parseES: Unknown stream type!\n");
                ;
        }
        if (result && strcmp(fileName, "NULL") != 0)
                result->setInput(fileName);
        
        delete [] fileName;
        return result;

}

/*
        u32 ContainerInfo::getActSize() const {
  return qinfo.steps[qinfo.currentQAStep]->size;
        }
*/

/*
        float ContainerInfo::getActQuality() const {
        return qinfo.steps[qinfo.currentQAStep]->quality;
        }
*/

bool ContainerInfo::destroy() {
        bool ret = true;
        if(localFile) {
                FILE *fp = fopen(this->localFile, "w");

                if (fp) {
                        fclose(fp);
#ifndef WINCE
                        remove(localFile);
#else
                        DeleteFile((LPCTSTR)localFile);
#endif
                        ret = true;
                }
        }
        
  list < ESInfo * >::iterator li = esList.begin();
        //  IO *io = NULL;

        while (li != esList.end()) {
                
                if ((localFile && strcmp(localFile, (*li)->getInput()) != 0) || !localFile) {
                        ret &= (*li)->destroy();
                }

                ++li;
        }
        if(localFile) {
    delete[] localFile;
    localFile = NULL;
        }
  return ret;
}


ESInfo *ContainerInfo::getES(u32 streamId) const {
  list < ESInfo * >::const_iterator li;
  if (esList.empty())
                return NULL;
  else
                li = esList.begin();
  while (li != esList.end()) {
                if ((*li)->getStreamId() == streamId)
            return (*li);
                ++li;
  }
  return NULL;
}


bool ContainerInfo::hasAudio() const {

        list < ESInfo * >::const_iterator li = esList.begin();
        while (li != esList.end()) {
                if ((*li)->isAudioStream())
            return true;
                ++li;
        }
        return false;
}


VideoESInfo *ContainerInfo::getFirstVisualES() {
        list < ESInfo * >::const_iterator li;
        
        if (esList.empty())     
                return NULL;
        
        li = esList.begin();
  while (li != esList.end()) {
                if ((*li)->isVisualStream())
            return (VideoESInfo*)(*li);
                ++li;
        }
        return NULL;
}


AudioESInfo *ContainerInfo::getFirstAudioES() {
        list < ESInfo * >::const_iterator li;
        
        if (esList.empty())     
                return NULL;
        
        li = esList.begin();
  while (li != esList.end()) {
                if ((*li)->isAudioStream())
            return (AudioESInfo*)(*li);
                ++li;
        }
        return NULL;
}



ContainerInfo * ContainerInfo::clone() {
    
        ContainerInfo * result = new ContainerInfo(this->qinfo);
  Url *uri = NULL;
  if (url) {
                uri = new Url(url->toString());
  }
    
        result->setUrl(uri);
        result->setLocalFile(this->localFile);
        result->type=this->type;
        if (this->iodHandle)
                result->setIODHandle(this->iodHandle, this->iodHandleSize);
  list < ESInfo * >::const_iterator li;
  if (!esList.empty()) {
                li = esList.begin();
                while (li != esList.end()) {
                        result->addESInfo((*li)->clone(result));
                        ++li;
                }
  }
    
        result->setLastRequestTime(this->lastAccessTime);
  return result;
}


void ContainerInfo::setMetaObject(MetaObject* meta) { metaObj=meta;};


MetaObject* ContainerInfo::getMetaObject() { return metaObj;};


rtx_group* ContainerInfo::getRtxGroup(u32 esId,list<rtx_group*>* rtxInfo) const {
        
        for(    list<rtx_group*>::iterator li=rtxInfo->begin();
                                li!=rtxInfo->end(); li++) {
                if( (*li)->es && esId==(*li)->es->getStreamId())
                        return *li;
        }
        return NULL;
}


const Url* ContainerInfo::getUrl() const {
        return url;
}


void ContainerInfo::setUrl(Url *uri) {
        if (url)
          delete url;
        url = uri;
}


void ContainerInfo::setLocalFile(const char* loclFile) {
        if(loclFile) {
                if(localFile)
                        delete[] localFile;
        }
        else
                return;

        localFile=new char[strlen(loclFile)+1];
        strcpy(localFile,loclFile);
        char* tmp=localFile;
#ifdef WIN32
        while(tmp=strchr(tmp,'/')) {
                *tmp='\\';
                tmp++;
        }
#else
        while((tmp=strchr(tmp,'\\')) != NULL) {
                *tmp='/';
                tmp++;
        }
#endif
}


ReferenceCounter* ContainerInfo::getUsageCounter() {
        return usageCounter;
}


u32 ContainerInfo::getFileSize() const {
        u32 filesize=0;
        FILE* fp=NULL;
        
        if(localFile && (fp=fopen(localFile,"rb"))) {
                fseek(fp,0,SEEK_END);
                long l=ftell(fp);
                if(l>0)
                        filesize=(u32)l;
                fclose(fp);
        }
        if(filesize==0) {
                // sum up the sizes of the demuxed streams
                std::list<ESInfo*>::const_iterator li;
                for(li=esList.begin();li!=esList.end();++li) {
                        filesize+=(*li)->getCurrentDemuxedMediaSize();
                }
        }
        return filesize;
}


u32 ContainerInfo::getEstimatedNetworkFileSize() {
        u32 filesize=0;
        std::list<ESInfo*>::iterator li;
        for(li=esList.begin();li!=esList.end();++li) {
                filesize+=(u32)((*li)->getAvgBandwidth() * ( ((double)(*li)->getDurationInMs())/8000.0));
        }
        return filesize;
}


u32 ContainerInfo::getNumberOfVisualStreams() const {
        u32 cnt=0;
        std::list<ESInfo*>::const_iterator li;
        for(li=esList.begin();li!=esList.end();++li) {
                        if((*li)->isVisualStream())
                                cnt++;
        }
        return cnt;
}


u32 ContainerInfo::getNumberOfAudioStreams() const {
        u32 cnt=0;
        std::list<ESInfo*>::const_iterator li;
        for(li=esList.begin();li!=esList.end();++li) {
                        if((*li)->isAudioStream())
                                cnt++;
        }
        return cnt;
}

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