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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

TerminalCapabilities.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       TerminalCapabilities.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 "TerminalCapabilities.hpp"
#include "debug.hpp"
#include <string.h>

TerminalCapabilities::TerminalCapabilities() {
        maxDecoderBufferSizeInByte=0;
        maxDecoderBitRateInBit=0;
        displayBitsPerPixel=0;
        colorDisplay=0;
        displayWidth=0;
        displayHeight=0;
        displayRefreshRate=0;
        memoryStorageMB=0;
        networkCapacityInByte=0;
        minGuaranteedNetworkCapacityInByte=0;
        networkDelayVariationInMs=0;
        bufferingDelayInMs=0;
        numAudioChannels=0;
        audioBitsPerSample=16;
        audioSamplingFrequency=44100;

};

TerminalCapabilities::TerminalCapabilities(
                                        u32 maxDecBufSize, u32 maxDecBitrate,
                                        u32 displayBits, bool color, 
                                        u32 width, u32 height, u32 refreshRate,
                                        float mem, u32 netCap, u32 minNetCap,
                                        u32 netDelayVar, u32 buffDelay, 
                                        u8 numAudioChann,u8 audiBitsPerSample,u32 samplFreq) {
        maxDecoderBufferSizeInByte=maxDecBufSize;
        maxDecoderBitRateInBit=maxDecBitrate;
        displayBitsPerPixel=displayBits;
        colorDisplay=(u32)color;
        displayWidth=width;
        displayHeight=height;
        displayRefreshRate=refreshRate;
        memoryStorageMB=mem;
        networkCapacityInByte=netCap;
        minGuaranteedNetworkCapacityInByte=minNetCap;
        networkDelayVariationInMs=netDelayVar;
        bufferingDelayInMs=buffDelay;
        numAudioChannels=numAudioChann;
        audioBitsPerSample=audiBitsPerSample;
        audioSamplingFrequency=samplFreq;
};

TerminalCapabilities* TerminalCapabilities::clone() const {
        return new TerminalCapabilities(
                                        maxDecoderBufferSizeInByte,
                                        maxDecoderBitRateInBit,
                                        displayBitsPerPixel, 
                                        (colorDisplay==0) ? false:true,
//                                      (((bool)colorDisplay)!=false),
                                        displayWidth,
                                        displayHeight,
                                        displayRefreshRate,
                                        memoryStorageMB,
                                        networkCapacityInByte,
                                        minGuaranteedNetworkCapacityInByte,
                                        networkDelayVariationInMs,
                                        bufferingDelayInMs,
                                        numAudioChannels,
                                        audioBitsPerSample,
                                        audioSamplingFrequency);
};

u32 TerminalCapabilities::getMaxDecoderBufferSizeInByte() const {
        return maxDecoderBufferSizeInByte;
};

u32 TerminalCapabilities::getMaxDecoderBitRateInBit() const {
        return maxDecoderBitRateInBit;
};

u32 TerminalCapabilities::getDisplayBitsPerPixel() const {
        return displayBitsPerPixel;
};

bool TerminalCapabilities::getColorDisplay() const {
        return colorDisplay!=0;
};

u32 TerminalCapabilities::getDisplayWidth() const {
        return displayWidth;
};

u32 TerminalCapabilities::getDisplayHeight() const {
        return displayHeight;
};

u32 TerminalCapabilities::getDisplayRefreshRate() const {
        return displayRefreshRate;
};

float TerminalCapabilities::getMemoryStorageMB() const {
        return memoryStorageMB;
};

u32 TerminalCapabilities::getNetworkCapacityInByte() const {
        return networkCapacityInByte;
};

u32 TerminalCapabilities::getMinGuaranteedNetworkCapacityInByte() const {
        return minGuaranteedNetworkCapacityInByte;
};

u32 TerminalCapabilities::getNetworkDelayVariationInMs() const {
        return networkDelayVariationInMs;
};

u32 TerminalCapabilities::getBufferingDelayInMs() const {
        return bufferingDelayInMs;
};

u8 TerminalCapabilities::getNumAudioChannels() const 
{
        return numAudioChannels;
};

bool TerminalCapabilities::supportsAudio() const
{
        return numAudioChannels>0;
};

u8 TerminalCapabilities::getAudioBitsPerSample() const
{
        return audioBitsPerSample;
};

u32 TerminalCapabilities::getAudioSamplingFrequency() const
{
        return audioSamplingFrequency;
};

void TerminalCapabilities::setMaxDecoderBufferSizeInByte(const u32 t) { 
        maxDecoderBufferSizeInByte=t;
};

void TerminalCapabilities::setMaxDecoderBitRateInBit(const u32 t) { 
        maxDecoderBitRateInBit=t;
};

void TerminalCapabilities::setDisplayBitsPerPixel(const u32 t) { 
        displayBitsPerPixel=t;
};

void TerminalCapabilities::setColorDisplay(const bool c) { 
        colorDisplay=(u32)c;
};

void TerminalCapabilities::setDisplayWidth(const u32 w) { 
        displayWidth=w;
};

void TerminalCapabilities::setDisplayHeight(const u32 h) { 
        displayHeight=h;
};

void TerminalCapabilities::setDisplayRefreshRate(const u32 r) { 
        displayRefreshRate=r;
};

void TerminalCapabilities::setMemoryStorageMB(const float s) { 
        memoryStorageMB=s;
};

void TerminalCapabilities::setNetworkCapacityInByte(const u32 c) { 
        networkCapacityInByte=c;
};

void TerminalCapabilities::setMinGuaranteedNetworkCapacityInByte(const u32 n) { 
        minGuaranteedNetworkCapacityInByte=n;
};

void TerminalCapabilities::setNetworkDelayVariationInMs(const u32 d) { 
        networkDelayVariationInMs=d;
};

void TerminalCapabilities::setBufferingDelayInMs(const u32 b) { 
        bufferingDelayInMs=b;
};

void TerminalCapabilities::setNumAudioChannels(const u8 ac)
{
        numAudioChannels=ac;
};

void TerminalCapabilities::setAudioBitsPerSample(const u8 ab)
{
        audioBitsPerSample=ab;
};

void TerminalCapabilities::setAudioSamplingFrequency(const u32 as)
{
        audioSamplingFrequency=as;
};

bool TerminalCapabilities::initFromFile(const char* file)
{
        FILE* fp=fopen(file,"rb");
        if(!fp) {
                return false;
        }
        fseek(fp,0L,SEEK_END);
        long size=ftell(fp);
        //rewind(fp);
        fseek(fp, 0L, SEEK_SET); 

        if(size==-1) {
                dprintf_err("TerminalCapabilities::initFromFile failed. Size of %s unknown\n",file);
                fclose(fp);
                return false;
        }
        char* buffer=new char[size+1];
        fread(buffer,1,size,fp);
        fclose(fp);
        char* pBuf=strstr(buffer,"maxDecoderBufferSizeInByte");
        if(pBuf) {
                sscanf(pBuf,"maxDecoderBufferSizeInByte %u", &maxDecoderBufferSizeInByte);
        }
        pBuf=strstr(buffer,"maxDecoderBitRateInBit");
        if(pBuf) {
                sscanf(pBuf,"maxDecoderBitRateInBit %u", &maxDecoderBitRateInBit);
        }
        pBuf=strstr(buffer,"displayBitsPerPixel");
        if(pBuf) {
                sscanf(pBuf,"displayBitsPerPixel %u", &displayBitsPerPixel);
        }
        pBuf=strstr(buffer,"colorDisplay");
        if(pBuf) {
                sscanf(pBuf,"colorDisplay %u", &colorDisplay);
        }
        pBuf=strstr(buffer,"displayWidth");
        if(pBuf) {
                sscanf(pBuf,"displayWidth %u", &displayWidth);
        }
        pBuf=strstr(buffer,"displayHeight");
        if(pBuf) {
                sscanf(pBuf,"displayHeight %u", &displayHeight);
        }
        pBuf=strstr(buffer,"displayRefreshRate");
        if(pBuf) {
                sscanf(pBuf,"displayRefreshRate %u", &displayRefreshRate);
        }
        pBuf=strstr(buffer,"memoryStorageMB");
        if(pBuf) {
                sscanf(pBuf,"memoryStorageMB %f", &memoryStorageMB);
        }
        pBuf=strstr(buffer,"networkCapacityInByte");
        if(pBuf) {
                sscanf(pBuf,"networkCapacityInByte %u", &networkCapacityInByte);
        }
        pBuf=strstr(buffer,"minGuaranteedNetworkCapacityInByte");
        if(pBuf) {
                sscanf(pBuf,"minGuaranteedNetworkCapacityInByte %u", &minGuaranteedNetworkCapacityInByte);
        }
        pBuf=strstr(buffer,"networkDelayVariationInMs");
        if(pBuf) {
                sscanf(pBuf,"networkDelayVariationInMs %u", &networkDelayVariationInMs);
        }
        pBuf=strstr(buffer,"bufferingDelayInMs");
        if(pBuf) {
                sscanf(pBuf,"bufferingDelayInMs %u", &bufferingDelayInMs);
        }
        pBuf=strstr(buffer,"bufferingDelayInMs");
        if(pBuf) {
                sscanf(pBuf,"bufferingDelayInMs %u", &bufferingDelayInMs);
        }
        u32 tmp=0;
        pBuf=strstr(buffer,"numAudioChannels");
        if(pBuf) {
                sscanf(pBuf,"numAudioChannels %u", &tmp);
                numAudioChannels=(u8)tmp;
        }
        pBuf=strstr(buffer,"audioBitsPerSample");
        if(pBuf) {
                sscanf(pBuf,"audioBitsPerSample %u", &tmp);
                audioBitsPerSample=(u8)tmp;
        }
        pBuf=strstr(buffer,"audioSamplingFrequency");
        if(pBuf) {
                sscanf(pBuf,"audioSamplingFrequency %u", &tmp);
                audioSamplingFrequency=tmp;
        }
        delete buffer;
        return true;
};

bool TerminalCapabilities::saveToFile(const char* file, bool overWrite) const
{
        FILE* fp=NULL;
        
        if(!overWrite) {
                fp=fopen(file,"rb");
                if(fp) {
                        // we are not allowed to overwrite this file
                        dprintf_err("TerminalCapabilities::saveToFile %s not allowed. File exists\r\n",
                                                                file);
                        fclose(fp);
                        return false;
                }
        }
        
        fp=fopen(file,"wb");
        
        if(!fp) {
                dprintf_err(
                        "TerminalCapabilities::saveToFile %s failed. Couldn't open/create file\r\n",
                        file);
                return false;
        }
        
        fprintf(fp,"maxDecoderBufferSizeInByte %u\n", maxDecoderBufferSizeInByte);
        fprintf(fp,"maxDecoderBitRateInBit %u\n", maxDecoderBitRateInBit); 
        fprintf(fp,"displayBitsPerPixel %u\n", displayBitsPerPixel); 
        fprintf(fp,"colorDisplay %u\n", colorDisplay); 
        fprintf(fp,"displayWidth %u\n", displayWidth); 
        fprintf(fp,"displayHeight %u\n", displayHeight); 
        fprintf(fp,"displayRefreshRate %u\n", displayRefreshRate);
        fprintf(fp,"memoryStorageMB %f\n", memoryStorageMB); 
        fprintf(fp,"networkCapacityInByte %u\n", networkCapacityInByte); 
        fprintf(fp,"minGuaranteedNetworkCapacityInByte %u\n", minGuaranteedNetworkCapacityInByte); 
        fprintf(fp,"networkDelayVariationInMs %u\n", networkDelayVariationInMs); 
        fprintf(fp,"bufferingDelayInMs %u\n", bufferingDelayInMs); 
        fprintf(fp,"numAudioChannels %u\n", numAudioChannels);
        fprintf(fp,"audioBitsPerSample %u\n", audioBitsPerSample);
        fprintf(fp,"audioSamplingFrequency %u\n", audioSamplingFrequency);

        fclose(fp);
        return true;
};

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