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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ESInfo.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:   ESInfo.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 "ESInfo.hpp"
#ifndef WINCE
#include <iostream>
#endif
#include "ContainerInfo.hpp"
#include "BitField.hpp"
#include "ReferenceCounter.hpp"

#include "container/ffMP4ContainerFile.hpp"
#include "container/ISOMP4ContainerFile.hpp"


#include "net/SDP.hpp"

ESInfo::ESInfo(u64 streamid, u32 streamtype, ContainerInfo * vob, u32 timeIncrement,
                                                         u8 * encodeddecconf, u32 objtype,
                                                         u32 bufsize, u32 avgBand, u32 maxBand,
                                                         u32 timeScale, u64 dur, u32 size, bool comp, 
                                                         CodecID codecID, float stQuality) {
        dprintf_full("ESInfo::ESInfo created with duration %llu timeIncrement %u avgBW %u kbps\n",
                                                         dur, timeIncrement,avgBand/1024);
        assert(timeScale>0); // otherwise div zero Bugs are possible
        description[0]='\0';
        frameStatistic=NULL;
  decConfUpdated=false;
  input = NULL;
  streamId = streamid;
  vo = vob;
  encodedDecoderConfig = encodeddecconf;
  objectType = objtype;
  streamType = streamtype;
  bufferSize = bufsize;

  avgBandwidth = avgBand;
  maxBandwidth = maxBand;
  mediaTimeScale = timeScale;
  duration = dur;
  mediaSize = size;
        vopTimeIncrement=timeIncrement;
        complete=comp;
        existingClones=NULL;
        usageCounter=new ReferenceCounter();
  codec_id = codecID;   
  quality = stQuality;
        generateDescriptionText();
}


ESInfo::~ESInfo() {
        dprintf_full("ESInfo::~ESInfo(): input %s streamId %llu\n", (input?input:"NULL"), streamId);
        if (input)
                delete[] input;
        
        if (encodedDecoderConfig)
                delete[] encodedDecoderConfig;

        if(frameStatistic)
                delete frameStatistic;

        if(existingClones && existingClones->decreaseAndDeactivateWhenUsage(0)) {
                delete existingClones;
                existingClones=NULL;
        }
        if(usageCounter) {
                delete usageCounter;
                usageCounter=NULL;
        }
}



void ESInfo::setEncodedDecoderConfig(u8 * enc) {
        if (encodedDecoderConfig)
                delete encodedDecoderConfig;
        encodedDecoderConfig = enc;

        decConfUpdated=true;
}


void ESInfo::setDecoderConfig(const u8 * dec, int size) {
        u8* dummy = new u8[size * 2 + 1];
        SDP::encodeDecoderConfig(dummy, dec, size);
        setEncodedDecoderConfig(dummy);
}


void ESInfo::setInput(const char *inp) {
        dprintf_full("ESInfo::setInput: old input %s new input %s\n",(input?input:"NULL"),(inp?inp:"NULL"));
        if (!inp)
                return;
        if (input)
                delete[] input;
        input = new char[strlen(inp) + 1];
        strcpy(input, inp);
        char* tmp=input;
#ifdef WIN32
        while(tmp=strchr(tmp,'/')) {
                *tmp='\\';
                tmp++;
        }
#else
        while((tmp=strchr(tmp,'\\')) != NULL) {
                *tmp='/';
                tmp++;
        }
#endif
}

u32 ESInfo::getHeaders(u8 **pHeaders) const
{
        if (!encodedDecoderConfig) {
                dprintf_err("ESInfo::getHeaders No decoder Config found\n");
                return 0;
        }
        assert( (*pHeaders) == NULL);
        int size = strlen((char *) encodedDecoderConfig);
        if (size < 1) {
                dprintf_err("ESInfo::getHeaders %llu: Failed to get EncodedDecoderConfig, got %s\n",
                                                                streamId, encodedDecoderConfig);
                return 0;
        }
        
        u8 *decConf = new u8[size / 2 + 1];
        SDP::decodeDecoderConfig(decConf, encodedDecoderConfig, size);
        // problem: decoderConfig is some extended Header
        // we have some leading bytes, and then we have 00 00 01h, the start of the header
        // so search for this hex value
        int i = 0;
        u32 data = 65535;
        u32 offset = 0;
        // generic streams have different headers 
        if (!isVisualStream() && !isAudioStream()) {
                i = size / 2; // do not change them
        }
        
        while (i < size / 2 - 1 && (data & 0x00FFFFFF) != 1) {
                data <<= 8;
                data += decConf[i];
                i++;
        }
        if ((data & 0x00FFFFFF) == 1) { // we read 2 zeros followed by a 1
                // found the header
                dprintf_full("ESInfo::getHeaders: Found header in decconf %x\n", data);
                // then set offset to point to the first 0
                // i points after the 1 -> header is 00 00 01 xx-> reduce by 3
                // 00 01 02 03 00 00 01 xx -> i=7 -> i=4
                offset = i - sizeof(data) + 1;
        }
        
        *pHeaders= new u8[size / 2 - offset+1];
        memcpy(*pHeaders, (decConf + offset), size / 2 - offset);
        (*pHeaders)[size / 2 - offset] = 0;
        dprintf_full
                ("ESInfo::getHeaders: Offset is %i, header size is %i first 4 bytes are %x %x %x %x\n",
                 offset, (size/2-offset),decConf[offset], decConf[offset + 1], decConf[offset + 2],
                 decConf[offset + 3]);
        
        delete[] decConf;
        return size / 2 - offset;
};

u32 ESInfo::getFrameNumber(double timeInSeconds, bool upround) const {
        // Example: 2.5 seconds, framerate is 25
        // the result is 25*2.5=37
        u32 result;
        if (upround)
                result=(u32)ceil(timeInSeconds*((double)mediaTimeScale)/((double)vopTimeIncrement));
        else
                result=(u32)floor(timeInSeconds*((double)mediaTimeScale)/((double)vopTimeIncrement));
        dprintf_full("ESInfo::getFrameNumber(%f) == No %i (rounded %s)\r\n",timeInSeconds,result,upround?"up":"down");
        return result;
};

/* calculate media time in seconds from frame number */
double ESInfo::getMediaTime(u32 frameNo) const
{
  if (!mediaTimeScale) {
    dprintf_err("ESInfo::getMediaTime(frameNo = %u) ERROR: mediaTimeScale is 0!\n", frameNo);
    return 0.0;
  }
  return (double) frameNo * (double) vopTimeIncrement / (double) mediaTimeScale;
}

bool ESInfo::enableFrameStatistic()
{
        dprintf_full("ESInfo::enableFrameStatistic\n");
        if(frameStatistic==NULL) {
                frameStatistic=new BitField(getNumberOfMediaSamples(),false);
                return true;
        }
        return false;
};

/* frees an existing frame statistics object */
void ESInfo::disableFrameStatistic()
{
        dprintf_full("ESInfo::disableFrameStatistic\n");
        if(frameStatistic) {
                delete frameStatistic;
                frameStatistic=NULL;
        }
};

BitField* ESInfo::getFrameStatistic()
{
        return frameStatistic;
}

void ESInfo::setFrameStatistic(BitField* b)
{
        if(frameStatistic)
                delete frameStatistic;
        frameStatistic=b;
};

void ESInfo::setDuration(u64 uiDuration)
{
  duration = uiDuration;
  if(frameStatistic) {
    BitField* b=frameStatistic;
    frameStatistic=b->createWithNewSize(getNumberOfMediaSamples(),false);
    delete b;
  }
}

void ESInfo::setVOPTimeIncrement(u32 ticks) {
        assert(ticks>0);
        vopTimeIncrement = ticks;
        dprintf_full("ESInfo (0x%p)::setVOPTimeIncrement to %u (duration %llu) mediaTimeScale is %u ticks\n",
                                                         this, ticks, duration, getMediaTimeScale());
        if(frameStatistic) {
                BitField* b=frameStatistic;
                frameStatistic=b->createWithNewSize(getNumberOfMediaSamples(),false);
                delete b;
        }
};

bool ESInfo::getCompleteState() const {
        if(this->frameStatistic)
                return frameStatistic->isAllSet();
        return complete;
};
 


void ESInfo::setCloneCounter( ReferenceCounter* &ref)
{
        if(existingClones && existingClones->decreaseAndDeactivateWhenUsage(0)) {
                delete existingClones;
                existingClones=NULL;
        }
        else if(existingClones && existingClones->getUsage()>0) {
                existingClones->decrease();
        }
        existingClones=ref;
};




u32 ESInfo::getCurrentDemuxedMediaSize() const
{
        if(!input)
                return 0;
        FILE* fp=fopen(this->input,"rb");
        u32 res=0;
        if(fp) {
                fseek(fp,0,SEEK_END);
                long l=ftell(fp);
                fclose(fp);
                if(l>0)
                        res=(u32)l;
        }
        return res;
};

bool ESInfo::destroy()
{
        bool ret=false;
        if(input) {
#ifndef WINCE
                        ret=(remove(input)==0);
#else
                        ret=(DeleteFile((LPCTSTR)input)!=0);
#endif
                //hack to remove possible hint files
                char* tmp=new char[strlen(input)+6];
                strcpy(tmp,input);
                strcat(tmp,".hint");
#ifndef WINCE
                remove(tmp);
#else
                DeleteFile((LPCTSTR)tmp);
#endif

                delete[] tmp;
                delete[] input;
                input=NULL;
                disableFrameStatistic();
                enableFrameStatistic();
        }
        return ret;
}

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