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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

VideoESInfo.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:   VideoESInfo.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.                                                 *
 *                                                                      *
 ***********************************************************************/
#include "VideoESInfo.hpp"
#include "adaptors/MP4Decoder.hpp"
#include "ReferenceCounter.hpp"
#include "BitField.hpp"

VideoESInfo::VideoESInfo(u32 streamId, u32 streamtype, ContainerInfo * vob, u32 timeIncrement,
                                                                                                 u8 * encodeddecconf, u32 objtype, u32 bufsize,
                                                                                                 u32 avgBW, u32 maxBW, u32 timeScale,
                                                                                                 u64 duration, u32 size,  
                                                                                                 u32 w, u32 h, bool isColorVideo,
                                                                                                 bool complete, 
                                                                                                 CodecID codec_id, float quality, float AspectRatio, bool staticFrameP, u32 gop_size, 
                                                                                                 u32 B_Frames,float avgBFrmeSize)
        : ESInfo(streamId,
                                         streamtype,vob,timeIncrement,encodeddecconf,
                                         objtype,bufsize,avgBW,maxBW,
                                         timeScale,duration,size,complete,codec_id,quality)
{
  width = w;
  height = h;
  aspect_ratio = AspectRatio;
  hasColor=isColorVideo;
  GOP_size = gop_size;
  num_B_frames = B_Frames;
        staticFramePattern=staticFrameP;
        setAvgBFrameSize(avgBFrameSize);
        
  // if ffmpeg fails to give width & height for video then get it from the ES
#ifndef ISOMP4
  if (w <= 0 || h <= 0) {

    MP4Decoder *mp4 = new MP4Decoder(this,false);
    mp4->initialize();
    delete mp4;
  }

#else
  if (handlerType == MP4VisualHandlerType) {
    MP4Decoder *mp4 = new MP4Decoder(this,false);
    mp4->initialize();
    delete mp4;
  }
#endif
        generateDescriptionText();
        dprintf_full("VideoESInfo created with size %ix%i aspect %2.2f color %i\n",width,height,aspect_ratio,hasColor);
};

void VideoESInfo::setAvgBFrameSize(float avgBFrmeSize)
{
        if(avgBFrmeSize<0.0 || avgBFrmeSize>=1.0) {
                // GUESS values
                // for non-static patterns assume 20%
                if(!staticFramePattern)
                        avgBFrameSize=0.2f;
                else {
                        //assume 20% for 1 B-frame between, +10% for each additional B-frame
                        if(num_B_frames==0)
                                avgBFrameSize=0.0;
                        else {
                                avgBFrameSize=0.2+ (num_B_frames-1)*0.1;
                                if(avgBFrameSize>0.9)
                                        avgBFrameSize=0.9f;
                        }
                        
                }
        }
        else
                avgBFrameSize=avgBFrmeSize;
        generateDescriptionText();
};

float VideoESInfo::getAvgBFrameSize() const
{
        return avgBFrameSize;
}

u32 VideoESInfo::getHandlerType() const
{
        return MP4VisualHandlerType;
};

u32 VideoESInfo::getWidth() const {
        return width;
};
u32 VideoESInfo::getHeight() const {
        return height;
};
void VideoESInfo::setWidth(u32 uiWidth) {
        width = uiWidth;
        generateDescriptionText();
};
void VideoESInfo::setHeight(u32 uiHeight) {
        height = uiHeight;
        generateDescriptionText();
};

float VideoESInfo::getAspectRatio() const {
        return aspect_ratio;
}

void VideoESInfo::setAspectRatio(float AspectRatio) {
        aspect_ratio = AspectRatio;
                                generateDescriptionText();
}

u32 VideoESInfo::getGOP_size() const {
        return GOP_size;
}

void VideoESInfo::setGOP_size(u32 gop_size) {
        GOP_size = gop_size;
        generateDescriptionText();
}

u32 VideoESInfo::getNum_B_frames() const {
        return num_B_frames;
}

void VideoESInfo::setNum_B_frames(u32 n_B_Frames) {
        num_B_frames = n_B_Frames;
        generateDescriptionText();
}

void VideoESInfo::setFPS(float fps) {
        assert(mediaTimeScale > 0);
        vopTimeIncrement = (u32)ceil(mediaTimeScale / fps);
}
        
float VideoESInfo::getFPS() const {
        if(vopTimeIncrement==0)
                return 0.0;
        return (float)((double)mediaTimeScale)/((double)vopTimeIncrement);
};


bool VideoESInfo::getHasColor() const 
{
        return hasColor;
};

void VideoESInfo::setHasColor(bool col) 
{
        hasColor=col;
        generateDescriptionText();
};

bool VideoESInfo::isVisualStream() const
{
        return true;
};
bool VideoESInfo::isAudioStream() const
{
        return false;
};
bool VideoESInfo::isODStream() const
{
        return false;
};
bool VideoESInfo::isSceneDescriptionStream() const
{
        return false;
};

void VideoESInfo::setEncodedDecoderConfig(u8 * enc)
{
        if (encodedDecoderConfig)
                delete encodedDecoderConfig;
        encodedDecoderConfig = enc;
        /* FIXME: WHY IS THIS NEEDED???? it breaks a working decoding/adapting/encoding chain! */
        /*
        if (this->isVisualStream() ) { //hack to get decoded config
                MP4Decoder *mp4 = new MP4Decoder(this,false);
                mp4->initialize();
                delete mp4;
        }
        */
        decConfUpdated=true;
};

bool VideoESInfo::hasStaticFramePattern() const
{
        return staticFramePattern;
}

void VideoESInfo::setStaticFramePattern(bool pattern)
{
        staticFramePattern=pattern;
        generateDescriptionText();
}

ESInfo *VideoESInfo::clone(ContainerInfo * mp4)
{
        dprintf_full("ESInfo::clone id %llu\n",streamId);
        u8 *decConf = NULL;
        if (encodedDecoderConfig)
        {
                decConf = new u8[strlen((char *) encodedDecoderConfig) + 1];
                strcpy((char *) decConf, (const char *) encodedDecoderConfig);
        }
        ESInfo *es = new VideoESInfo(streamId, streamType, mp4, vopTimeIncrement, decConf, objectType,
                                                                                                        bufferSize, avgBandwidth, maxBandwidth,
                                                                                                        mediaTimeScale, duration, mediaSize, width, height,
                                                                                                        hasColor,complete, codec_id, this->quality, aspect_ratio, staticFramePattern,
                                                                                                        GOP_size, num_B_frames);
        es->setInput(input);
        
        if(!existingClones) {
                existingClones=new ReferenceCounter();
                existingClones->increase(); // for this object
        }
        existingClones->increase(); // for clone object
        es->setCloneCounter(existingClones);
        BitField* fs=getFrameStatistic();
        if(fs) {
                es->setFrameStatistic(fs->createWithNewSize(fs->getSize(),false));
        }
        return es;
};

void VideoESInfo::generateDescriptionText() {
        char *codecName = new char[MAX_STR_LEN];
        strcpy(codecName,"Unknown");
#ifdef ENABLE_FFMPEG
        AVCodec* av=avcodec_find_decoder(this->codec_id);
        if(av)
                strcpy(codecName,av->name);
#endif
        snprintf(description,MAX_STR_LEN,"%10s: %4ukBps; %4ux%4u; %2.1f/%1uB",
                                         codecName,avgBandwidth/1024,width,height,getFPS(),num_B_frames);
        delete [] codecName;
}

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