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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP21.cpp

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

const char* const MP21::openHeader="<xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<DIDL xmlns=\"urn:mpeg:mpeg21:dia:schema:2003\">";
const char* const MP21::closeHeader="</DIDL>";
const char* const MP21::boolStrings[2]={"FALSE","TRUE"};
const char* MP21::getMP21DocumentOpeningHeader() { 
        return openHeader;
};

const char* MP21::getMP21DocumentClosingHeader() {
        return closeHeader;
};

char* MP21::generateTerminalCapabilityDescription(const TerminalCapabilities* tc) {
        /*create a minimum MPEG21 description
        <TerminalCapabilities>
                <InputOutput>
                        <Display bitsPerPixel="8" colorCapable="TRUE" refreshRate="60">
                                <Resolution horizontal="352" vertical="288"/>
                        </Display>              
                </InputOutput>
                <AudioOut samplingFrequency="44100" bitsPerSample="16" numChannels="1"/>
                <DeviceProperty>
                        <Storage>
                                <Device Size="4.5"/> <!-- in MByte -->
                        </Storage>      
                        <Network>       
                                <NetworkCapability maxCapacity="64000" minGuaranteed="32000"/>
                                <Delay delayVariation="25"/>
                        </Network>      
                </DeviceProperty>
        </TerminalCapabilities>         */
        char *buffer = new char[32768];
        char* pBuffer=buffer;
        strcpy(buffer, openHeader);
        pBuffer+=strlen(openHeader);
        sprintf(pBuffer,"\t<TerminalCapabilities>\r\n\t\t<InputOutput>\r\n\t\t\t");
        pBuffer+=strlen(pBuffer);
        // write IO part
        sprintf(pBuffer,"<Display bitsPerPixel=\"%u\" colorCapable=\"%s\" refreshRate=\"%u\">\r\n"
                                        "\t\t\t\t<Resolution horizontal=\"%u\" vertical=\"%u\"/>\r\n"
                                        "\t\t\t</Display>\r\n\t\t</InputOutput>\r\n",
                                        tc->getDisplayBitsPerPixel(),
                                        boolStrings[tc->getColorDisplay()],
                                        tc->getDisplayRefreshRate(),
                                        tc->getDisplayWidth(),tc->getDisplayHeight());
        pBuffer+=strlen(pBuffer);
        // generate Audio
        if(tc->supportsAudio()) {
                sprintf(pBuffer,"\t\t<AudioOut samplingFrequency \"%u\" bitsPerSample \"%u\" numChannels=\"%u\"/>\r\n",
                        tc->getAudioSamplingFrequency(),tc->getAudioBitsPerSample(),tc->getNumAudioChannels());
                pBuffer+=strlen(pBuffer);
        }
        // write DeviceProperty
        sprintf(pBuffer,"\t\t<DeviceProperty>\r\n"
                                        "\t\t\t<Storage>\r\n"
                                        "\t\t\t\t<Device Size=\"%f\"/>\r\n"
                                        "\t\t\t</Storage>\r\n"
                                        "\t\t\t<Network>\r\n"
                                        "\t\t\t\t<NetworkCapability maxCapability=\"%i\" minGuaranteed=\"%i\"/>\r\n"
                                        "\t\t\t\t<Delay delayVariation=\"%i\"/>\r\n"
                                        "\t\t\t</Network>\r\n"
                                        "\t\t</DeviceProperty>\r\n"
                                        "\t</TerminalCapabilities>\r\n"
                                        ,
                                        tc->getMemoryStorageMB(),
                                        tc->getNetworkCapacityInByte(),tc->getMinGuaranteedNetworkCapacityInByte(),
                                        tc->getNetworkDelayVariationInMs());
        pBuffer+=strlen(pBuffer);
        strcat(pBuffer,closeHeader);
        char* result=new char[strlen(buffer)+1];
        strcpy(result,buffer);

        delete [] buffer;
        return result;
};

TerminalCapabilities* MP21::createTerminalCapability(const char* mp21string) {
        // look for openheader
        if(strstr(mp21string,MP21::openHeader)==NULL)
                return NULL;

        TerminalCapabilities* tc=new TerminalCapabilities();
        // lazy  parsing
        char* pBuffer=strstr(mp21string, "<Display");
        char* pBufferEnd=NULL;
        if(pBuffer) {
                pBufferEnd=strstr(pBuffer, "</Display>");
        }
        char *sTemp = new char[2000];
        int temp;
        if(pBuffer && pBufferEnd) {
                if(findIntAfterToken(pBuffer,pBufferEnd,"bitsPerPixel",&temp))
                        tc->setDisplayBitsPerPixel((u8)temp);
                if(findStringAfterToken(pBuffer,pBufferEnd,"colorCapable",sTemp)) {
                        if((strcmp(sTemp,"TRUE")==0) || (strcmp(sTemp,"true")==0) ) {
                                tc->setColorDisplay(true);
                                dprintf_full("MP21::createTerminalCapability: found true: X%sX\r\n",sTemp);
                        }
                        else {
                                dprintf_full("MP21::createTerminalCapability: found true: X%sX\r\n",sTemp);
                                tc->setColorDisplay(false);
                        }
                }
                if(findIntAfterToken(pBuffer,pBufferEnd,"refreshRate",&temp))
                        tc->setDisplayRefreshRate(temp);
                if(findIntAfterToken(pBuffer,pBufferEnd,"horizontal",&temp))
                        tc->setDisplayWidth(temp);
                if(findIntAfterToken(pBuffer,pBufferEnd,"vertical",&temp))
                        tc->setDisplayHeight(temp);
        }
        // search Audio part
        //      <AudioOut samplingFrequency="44100" bitsPerSample="16" numChannels="1"/>
        pBuffer=NULL;pBufferEnd=NULL;
        pBuffer=strstr(mp21string,"<AudioOut");
        if(pBuffer)
                pBufferEnd=strstr(pBuffer,"/>");
        if(pBuffer && pBufferEnd) {
                if(findIntAfterToken(pBuffer,pBufferEnd,"samplingFrequency",&temp))
                        tc->setAudioSamplingFrequency(temp);
                if(findIntAfterToken(pBuffer,pBufferEnd,"bitsPerSample",&temp))
                        tc->setAudioBitsPerSample((u8)temp);
                if(findIntAfterToken(pBuffer,pBufferEnd,"numChannels",&temp))
                        tc->setNumAudioChannels((u8)temp);
        }
        
        pBuffer=NULL;pBufferEnd=NULL;
        pBuffer=strstr(mp21string,"<DeviceProperty>");
        if(pBuffer)
                pBufferEnd=strstr(mp21string,"</DeviceProperty>");

        if(pBuffer && pBufferEnd) {
                char* pStorage=strstr(pBuffer,"<Storage>");
                char* pStorageEnd=strstr(pBuffer,"</Storage>");
                if(pStorage && pStorageEnd) {
                        float result;
                        if(findFloatAfterToken(pStorage,pStorageEnd,"Size",&result))
                                tc->setMemoryStorageMB(result);
                }
                pStorage=strstr(pBuffer,"<Network>");
                pStorageEnd=strstr(pBuffer,"</Network>");
                if(pStorage && pStorageEnd) {
                        if(findIntAfterToken(pStorage,pStorageEnd,"maxCapability",&temp))
                                tc->setNetworkCapacityInByte(temp);
                        if(findIntAfterToken(pStorage,pStorageEnd,"minGuaranteed",&temp))
                                tc->setMinGuaranteedNetworkCapacityInByte(temp);
                        if(findIntAfterToken(pStorage,pStorageEnd,"delayVariation",&temp))
                                tc->setNetworkDelayVariationInMs(temp);
                }
        }
        delete [] sTemp;
        return tc;
};

bool MP21::findIntAfterToken(const char* input, const char* inputEnd,
                                                         const char* token, int* result) {
        char* temp=strstr(input,token);
        if(!temp )
                return false;
        if(temp>inputEnd)
                return false;
        temp+=strlen(token); // point after token
        // found the token
        // after the token the only valid chars are '=', ' ' and stop condition is '"'
        while(  (*temp)=='=' ||
                        (*temp)==' ') {
                temp++;
        }
        if(*temp=='"') {
                temp++;
                if(temp>inputEnd)
                        return false;
                return (sscanf(temp,"%i",result)==1);
        }
        return false;
};

bool MP21::findFloatAfterToken(const char* input, const char* inputEnd,
                                                         const char* token, float* result) {
        char* temp=strstr(input,token);
        if(!temp )
                return false;
        if(temp>inputEnd)
                return false;
        temp+=strlen(token); // point after token
        // found the token
        // after the token the only valid chars are '=', ' ' and stop condition is '"'
        while(  (*temp)=='=' ||
                        (*temp)==' ') {
                temp++;
        }
        if(*temp=='"') {
                temp++;
                if(temp>inputEnd)
                        return false;
                return (sscanf(temp,"%f",result)==1);
        }
        return false;
};


bool MP21::findStringAfterToken(const char* input, const char* inputEnd,
                                                                const char* token, char* result) {
        char* temp=strstr(input,token);
        if(!temp)
                return false;
        if(temp>inputEnd)
                return false;

        temp+=strlen(token); // point after token
        // found the token
        // after the token the only valid chars are = , ' ' and stop condition is '"'
        while(  (*temp)=='=' ||
                        (*temp)==' ') {
                temp++;
        }
        if(*temp=='"') {
                temp++;
                // find the closing '"' in the same line
                char* pEnd=temp;
                while(*pEnd!='"' && *pEnd!='\r' && *pEnd!='\n')
                        pEnd++;
                if(*pEnd=='"' && pEnd<=inputEnd) {
                        // valid
                        strncpy(result,temp,pEnd-temp);
                        result[pEnd-temp]='\0';
                        return true;
                }
        }
        return false;
};

char* MP21::generateUserPreferencesDescription(const UserPreferences* up)
{
        return up->toString();
}

UserPreferences* MP21::createUserPreferences(const char* mp21string)
{
        
        return UserPreferences::create(mp21string);
}

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