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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MetaObject.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MetaObject.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 "global.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "MetaObject.hpp"
#include "VideoAdaptorChain.hpp"



#include "net/Url.hpp"
#include "metadata/UserPreferences.hpp"


MetaObject::MetaObject(ContainerInfo* stream) {
        assert(stream);
        url=NULL;
        pendingOutsideUnlock=0;
        lockAccess.initialize("MetaObject-lockAccess");
        if(stream) {
                dprintf_full("MetaObject::MetaObject stream ok\n");
                if (stream->getUrl())
                {       
                        dprintf_full("MetaObject::MetaObject url ok\n");
                        url=new Url(stream->getUrl()->toString());
                }
                variations.push_back(stream);
        }
        stream->setMetaObject(this);
};

MetaObject::MetaObject(const char* configFile) {
        loadFromConfigFile(configFile);
};

MetaObject::~MetaObject() {
        lockAccess.destroy();
        delete url;

        list<ContainerInfo*>::iterator li;
        while(!variations.empty()) {
                li=variations.begin();
                delete (*li);
                variations.pop_front();
        }
};

double MetaObject::calcSimpleQuality(u32 min, u32 max, u32 val) {
        if(min==max) {
                if(min==val)
                        return 1.0;
        
                return 0.0;
        }
        if(min>max)
                return -1.0;
        if(min<=val && val <=max)
                return (((double)val)-min)/(max-min);

        return 0.0;
}



ContainerInfo* MetaObject::findMp4Stream(u32 lowerDimX, u32 upperDimX, 
                                                         u32 lowerDimY, u32 upperDimY, 
                                                         u32 lowerBitRate, u32 upperBitRate, 
                                                         bool greyScale, float frameRate,
                                                         bool* isExactMatch) {

        dprintf_full("MetaObject::findMp4Stream(u32 lowX=%u,u32 uppX=%u,u32 lowY=%u,u32"
                                                         " upY=%u,u32 lowBitRate=%u kbps, u32 upperBitRate=%u kbps,bool greyScale=%i)\n",
                                                         lowerDimX,upperDimX,lowerDimY,upperDimY,lowerBitRate/1024,upperBitRate/1024, (int)greyScale);
        lockAccess.lock();
        *isExactMatch=false;
        ContainerInfo* best=NULL;
        int maxHits=0;
        if(variations.empty()) {
                lockAccess.release();
                return NULL;
        }
        double bestQuality=0.0, currentQuality=0.0;     
        u32 bestBitRate;
        list<ContainerInfo*>::iterator li=variations.begin();
        while(li!=variations.end()) {
                // compare
                VideoESInfo* temp = (*li)->getFirstVisualES();
                AudioESInfo*    temp2= (*li)->getFirstAudioES();
                u32 sysBitRate= (temp2? temp2->getAvgBandwidth():0);
                sysBitRate+=(temp? temp->getAvgBandwidth():0);
                int countHits=0;
                countHits+=(sysBitRate>=lowerBitRate) ? 1 : 0;
                countHits+=(sysBitRate<=upperBitRate) ? 1 : 0;
                // problem with network: return the one version with the value
                // closest to the specified range, make sure this doesn't have a
                // too big influence in case other misses are encountered --> countHits are used for that!
                if(lowerBitRate<=upperBitRate) {
                        if(lowerBitRate<=sysBitRate && sysBitRate<=upperBitRate) {
                                currentQuality=1.0+calcSimpleQuality(lowerBitRate,upperBitRate,sysBitRate);
                        }
                        else {
                                // if out of range calc a value between 0..1 stating how many % we are off
                                if(sysBitRate < lowerBitRate && sysBitRate > lowerBitRate/2) {
                                        currentQuality=calcSimpleQuality(lowerBitRate/2,lowerBitRate,sysBitRate);
                                }
                                else if(sysBitRate> upperBitRate && sysBitRate < upperBitRate*2) {
                                        currentQuality=1.0-calcSimpleQuality(upperBitRate,upperBitRate*2,sysBitRate);
                                }
                                else
                                        currentQuality=0.0;
                        }
                }
                else
                        currentQuality=0.0;

                if(temp) {      
                        if(lowerDimX<=upperDimX && lowerDimY<upperDimY && upperDimX>32 && upperDimY>32) {
                                countHits+=(temp->getWidth()>=lowerDimX) ? 1 : 0;
                                countHits+=(temp->getHeight()>=lowerDimY) ? 1 : 0;
                                countHits+=(temp->getWidth()<=upperDimX) ? 1 : 0;
                                countHits+=(temp->getHeight()<=upperDimY) ? 1 : 0;
                                currentQuality+=calcSimpleQuality(lowerDimX,upperDimX,temp->getWidth());
                                currentQuality+=calcSimpleQuality(lowerDimY,upperDimY,temp->getHeight());
                        }
                        else {
                                /* ignore the incorrectly given dimension */
                                countHits+=4;   
                        }
                        countHits+=(greyScale!=temp->getHasColor()) ? 1 : 0;
                }
                else
                        countHits+=5;   //dim+greyscale

                if(frameRate>temp->getFPS())
                        countHits++;

                dprintf_full("MetaObject::findMp4Stream checking on width=%u, height=%u, bitRate=%u kbps,"
                                                                 " hasColor %i: quality %4.2f hits %i\n",
                                                                 temp->getWidth(),temp->getHeight(),sysBitRate/1024,temp->getHasColor(), currentQuality, countHits);


                if(countHits == 8) {
                        // a perfect hit
                        maxHits=countHits;
                        *isExactMatch=true;
                        dprintf_full("MetaObject::findMp4Stream found a perfect hit (exact match!)\r\n");
                        if(currentQuality > bestQuality || currentQuality <= 0.0) {
                                best=*li;
                                bestQuality = currentQuality;
                                bestBitRate = sysBitRate;
                        }
                }
                else if ((countHits >= maxHits) && (bestQuality  < currentQuality) ) {
                        // new best match
                        best=*li;
                        bestQuality=currentQuality;
                        maxHits=countHits;
                        bestBitRate = sysBitRate;
                }
                ++li;
        }
        dprintf_full("MetaObject::findMp4Stream has %i hits from 8, quality %4.2f\n",maxHits, bestQuality);
        lockAccess.release();
        if (best) {
                dprintf_full("MetaObject::findMp4Stream decides on Container with width=%u, height=%u, bitRate=%i kbps firstES id %llu (url %s)\n", 
                                                                 best->getFirstVisualES()->getWidth(),best->getFirstVisualES()->getHeight(), bestBitRate/1024, (*best->getESList()->begin())->getStreamId(), (*best->getESList()->begin())->getInput());
                return best;
        } else
                return NULL;
};

bool MetaObject::addMP4Stream(ContainerInfo* stream) {
        lockAccess.lock();
                
        list<ContainerInfo*>::iterator varCI;

        for(varCI=variations.begin(); varCI!=variations.end(); ++varCI) {
                // search within one variation for a similar ES entry
                if(stream->getUrl()->isEqual((*varCI)->getUrl())) {
                        // compare quality!
                        VideoESInfo* vIn=stream->getFirstVisualES();
                        VideoESInfo* v=(*varCI)->getFirstVisualES();
                        if(v->getWidth()==vIn->getWidth() && 
                                v->getAvgBandwidth()==vIn->getAvgBandwidth() &&
                                v->getFPS()>=vIn->getFPS()) {
                                        // we have same quality stored, delete the inserted one
                                        // for simplicity because the other is probably in use
                                        stream->destroy();
                                        delete stream;stream=NULL;
                                        lockAccess.release();
                                        return false;
                                }
                }
        }
        stream->setMetaObject(this);
        variations.push_back(stream);
        lockAccess.release();
        return true;

};

bool  MetaObject::deleteMP4Stream(ContainerInfo* stream) {
        lockAccess.lock();
        if(variations.empty())
                return false;

        list<ContainerInfo*>::iterator start,end;
        start=variations.begin();
        end=variations.end();
        bool found=false;
        while(start!=end) {
                if(stream == (*start) )
                        found=true;
                if( !found && (*start)->getLocalFile() && stream->getLocalFile()
                        && strcmp((*start)->getLocalFile(),stream->getLocalFile())==0)
                        found=true;
                if(!found && (*start)->getFirstVisualES() &&
                        (*start)->getFirstVisualES()->getInput() && 
                        stream->getFirstVisualES()->getInput() &&
                        strcmp((*start)->getFirstVisualES()->getInput(),stream->getFirstVisualES()->getInput()) == 0)
                        found=true;
                if(!found && (*start)->getFirstAudioES() &&
                        (*start)->getFirstAudioES()->getInput() && 
                        stream->getFirstAudioES()->getInput() &&
                        strcmp((*start)->getFirstAudioES()->getInput(),stream->getFirstAudioES()->getInput()) == 0)
                        found=true;
                if(found) {
                        delete (*start);
                        variations.erase(start);
                        lockAccess.release();
                        return true;
                }
                ++start;
        }               
        lockAccess.release();
        return false;
};

bool MetaObject::saveToConfigFile(const char* cfg) {
        lockAccess.lock();

        if(variations.empty() || !cfg || !this->url) {
                lockAccess.release();
                return false;
        }
        FILE* fp=fopen(cfg,"wb");
        bool retVal=false;
        char* pCfg=strrchr(cfg,'.');
        char *temp = new char[1024];
        if(pCfg) {
                strncpy(temp,cfg,pCfg-cfg-1); //do not copy the dot
                temp[pCfg-cfg-1]=0;
                pCfg=&temp[pCfg-cfg-1];
        }
        else {
                strcpy(temp,cfg);
                pCfg=&temp[strlen(temp)];
        }
        // pCfg is used for appending XX.conf
        if(fp) {
                char pCint[10];
                retVal=true;
                int i=0;
                fprintf(fp,"%s\n",this->url->toString());
                list<ContainerInfo*>::iterator start=variations.begin();
                while(start!=variations.end()) {
                        sprintf(pCint,"%2d",i);
                        strcpy(pCfg,pCint);
                        strcat(pCfg,".conf");
                        retVal&=(*start)->saveToCfgFile(temp);
                        if(retVal) {
                                fprintf(fp,"%s\n",temp);
                        }
                        ++start;
                        i++;
                }
                fclose(fp);
        }
        lockAccess.release();
        delete [] temp;
        return retVal;
};

bool MetaObject::loadFromConfigFile(const char* cfg) {
        FILE* fp=fopen(cfg,"rb");
        if(!fp)
                return false;

        lockAccess.lock();
        if(url) {
                delete url;
        }

        list<ContainerInfo*>::iterator start;
        while(!variations.empty()) {
                start=variations.begin();
                delete (*start);
                variations.pop_front();
        }

        // everything cleaned up
        bool retVal=true;
        char *line = new char[1024];
        fgets(line,1024,fp);
        // first line contains url
        url=new Url(line);
        
        // then read the objects
        ContainerInfo* info=NULL;
        //int counter=0;
        while(!feof(fp)) {
                fgets(line,1024,fp);
                info=new ContainerInfo();
                if(info->loadFromCfgFile(line)) {
                        variations.push_back(info);     
                }
                else
                        retVal=false;
        }
        fclose(fp);     
        lockAccess.release();
        delete [] line;
        return retVal;
};

std::list<ContainerInfo*>* MetaObject::getVariations() 
{
        lockAccess.lock();
        pendingOutsideUnlock++;
        return &variations;
};

void MetaObject::releaseVariationsLock()
{
        if(pendingOutsideUnlock>0) {
                pendingOutsideUnlock--;
                lockAccess.release();
        }
}

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