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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

M3SMetaInfo.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: M3SMetaInfo.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.                                                 *
 *                                                                      *
 ***********************************************************************/

/***********************************************************************
 *  Author: Klaus Schoeffmann                                           *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include "M3SMetaInfo.hpp"
#include "global.hpp"

#include <stdio.h>


/***********************************************************************/
M3SMetaInfo::M3SMetaInfo() {
        initialize();
}

/***********************************************************************/
M3SMetaInfo::~M3SMetaInfo() {
        if (videoFilepath != NULL) delete videoFilepath;
        if (audioFilepath != NULL) delete audioFilepath;
        if (http != NULL) delete http;
}

/***********************************************************************/
void M3SMetaInfo::initialize() {
        length = 0;
        
        videoEnabled = false;
        videoFilepath = NULL;
        fps = 0;
        videoKbps = 0;
        width = 0;
        height = 0;
        
        audioEnabled = false;
        audioFilepath = NULL;
        audioKbps = 0;
        numAudioChannels = 0;
        sampleRate = 0;
        http = NULL;
}

/***********************************************************************/
char *M3SMetaInfo::findParam(char *line, char *name, int *len) {
        char *pos = strstr(line, name);
        *len = 0;
        if (pos != NULL) {
                while (*pos != '=') pos++;
                while (*pos == ' ' || *pos == '=') pos++;
                char *tmppos = pos;
                while (*tmppos != '\r' && *tmppos != '\n') {
                        tmppos++;
                        (*len)++;
                }
        }
        return pos;
}

/***********************************************************************/
bool M3SMetaInfo::loadFromURL(const char *url) {
        dprintf_full("M3SMetaInfo::loadFromURL() starts...\n");

        http = new HttpRequest(url);
        
        if (http->makeHttpRequest()) {
                
                int contentLength = http->getContentLength();
                
                char *file = new char[contentLength]; //buffer for file-download
                u32 offset = 0;
                int bytesReceived = 0;
                
                while ((bytesReceived = http->continueReceive(file+offset, contentLength-offset)) != -1) {
                        offset += bytesReceived;
                }
                
                http->closeSock();
                
                //parse content
                parseFileContent(file, contentLength);
                delete [] file;
                
                return true;
        }
        return false;
}


/***********************************************************************/
int M3SMetaInfo::readLine(char **line, char *content, u32 &offset, u32 contentLength)
{
        int linelen = 0;
        *line = new char[LINE_SIZE];

        while (offset < contentLength && content[offset] != '\r' && content[offset] != '\n') {
                (*line)[linelen++] = content[offset++];
        }
        if (offset < contentLength && content[offset] == '\r') (*line)[linelen++] = content[offset++];
        if (offset < contentLength && content[offset] == '\n') (*line)[linelen++] = content[offset++];

        if (linelen == 0) delete [] (*line);

        return linelen;
}

/***********************************************************************/
void M3SMetaInfo::parseFileContent(char *content, u32 contentLength)
{
  int n = 0;
  u32 offset = 0;
  char *line = NULL; 

  char *buffer;
  int paramlen;
  SECTION sect = M3SMetaInfo::none;

  //read line by line until end of file
  while ((n = readLine(&line, content, offset, contentLength)) > 0)
  {

          if (line[0] == '#')
          {
                //ignore comments
          }
          else if (strncmp(line, "[General]",strlen("[General]")) == 0) {
                sect = M3SMetaInfo::general;
          }
          else if (strncmp(line, "[Video]",strlen("[Video]")) == 0) {
                sect = M3SMetaInfo::video;
          }
          else if (strncmp(line, "[Audio]",strlen("[Audio]")) == 0) {
                sect = M3SMetaInfo::audio;
          }
  
          else if (sect == M3SMetaInfo::general && (buffer = findParam(line, "length", &paramlen)) != NULL) {
                        length = (int)ceil(atof(buffer));
                dprintf_full("length=%d\n", length);
          }
  

          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "enable", &paramlen)) != NULL) {
                if (strncmp(buffer, "yes", 3) == 0) videoEnabled = true;
                dprintf_full("videoEnabled=%s\n", videoEnabled==true?"yes":"no");
          }
          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "filepath", &paramlen)) != NULL) {
                videoFilepath = new char [paramlen + 2];
                strncpy(videoFilepath, buffer, paramlen); 
                videoFilepath[paramlen] = '\0';
                dprintf_full("videoFilepath=%s\n", videoFilepath);
          }
          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "fps", &paramlen)) != NULL) {
                fps = atoi(buffer);
                dprintf_full("fps=%d\n", fps);
          }
          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "kbps", &paramlen)) != NULL) {
                videoKbps = atoi(buffer);
                dprintf_full("videokbps=%d\n", videoKbps);
          }
          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "width", &paramlen)) != NULL) {
                width = atoi(buffer);
                dprintf_full("width=%d\n", width);
          }
          else if (sect == M3SMetaInfo::video && (buffer = findParam(line, "height", &paramlen)) != NULL) {
                height = atoi(buffer);
                dprintf_full("height=%d\n", height);
          }
  
  
          else if (sect == M3SMetaInfo::audio && (buffer = findParam(line, "enable", &paramlen)) != NULL) {
                if (strncmp(buffer, "yes", 3) == 0) audioEnabled = true;
                dprintf_full("audioEnabled=%s\n", audioEnabled==true?"yes":"no");
          }
          else if (sect == M3SMetaInfo::audio && (buffer = findParam(line, "filepath", &paramlen)) != NULL) {
                audioFilepath = new char [paramlen + 2];
                strncpy(audioFilepath, buffer, paramlen);
                audioFilepath[paramlen] = '\0';
                dprintf_full("audioFilepath=%s\n", audioFilepath);
          }
          else if (sect == M3SMetaInfo::audio && (buffer = findParam(line, "kbps", &paramlen)) != NULL) {
                audioKbps = atoi(buffer);
                dprintf_full("audiokbps=%d\n", audioKbps);
          }
          else if (sect == M3SMetaInfo::audio && (buffer = findParam(line, "numchannels", &paramlen)) != NULL) {
                numAudioChannels = atoi(buffer);
                dprintf_full("numchannels=%d\n", numAudioChannels);
          }
          else if (sect == M3SMetaInfo::audio && (buffer = findParam(line, "samplerate", &paramlen)) != NULL) {
                sampleRate = atoi(buffer);
                dprintf_full("samplerate=%d\n", sampleRate);
          }
  
          else
          {
                //Unrecognized parameter ignored
          }

  } //while

}

/***********************************************************************/
bool M3SMetaInfo::loadFromFile(const char *filename) 
{

  dprintf_full("M3SMetaInfo::loadFromFile() starts..\n");
  
  //open file of users
  FILE *file = fopen(filename, "r");
  if (!file)
  {
        dprintf_err_fatal("M3SMetaInfo::loadFromFile() error opening file %s\n", filename);
        return false;
  } 

  //get file size
  fseek(file, 0, SEEK_END);
  u32 len = ftell(file);
  fseek(file, 0, SEEK_SET);

  //read content of file
  char *fileContent = new char[len];
  fread(fileContent, sizeof(char), len, file);
  fclose(file);

  //parse content
  parseFileContent(fileContent, len);

  delete [] fileContent;
  
  dprintf_full("M3SMetaInfo::loadFromFile() succeeded!\n");
  return true;
}


/***********************************************************************/
void M3SMetaInfo::setVideoFilepath(char *videoFilepath)
{
        if (this->videoFilepath != NULL) delete [] this->videoFilepath;

        this->videoFilepath = new char[strlen(videoFilepath) + 1];
        strcpy(this->videoFilepath, videoFilepath);
}

/***********************************************************************/
void M3SMetaInfo::setAudioFilepath(char *audioFilepath)
{
        if (this->audioFilepath != NULL) delete [] this->audioFilepath;

        this->audioFilepath = new char[strlen(audioFilepath) + 1];
        strcpy(this->audioFilepath, audioFilepath);
}

/***********************************************************************/
void M3SMetaInfo::appendVideoFilepath(int paramSize, char *prefix, int len)
{

        if ((signed)(len + strlen(getVideoFilepath())) >= paramSize) {
                dprintf_err_fatal("M3SMetaInfo::appendVideoFilepath() cannot change video-filepath - too long! (maximum length=%d)\n",paramSize);
        }

        char *tmp = new char[paramSize];
        strncpy(tmp, prefix, len);
        tmp[len] = '\0';
        strcat(tmp, getVideoFilepath());
        setVideoFilepath(tmp);
        delete [] tmp;
        dprintf_full("NEW VIDEO Filepath = %s\n", getVideoFilepath());
        
}

/***********************************************************************/
void M3SMetaInfo::appendAudioFilepath(int paramSize, char *prefix, int len)
{

        if ((signed)(len + strlen(getAudioFilepath())) >= paramSize) {
                dprintf_err_fatal("M3SMetaInfo::appendAudioFilepath() cannot change audio-filepath - too long! (maximum length=%d)\n",paramSize);
        }

        char *tmp = new char[paramSize];
        strncpy(tmp, prefix, len);
        tmp[len] = '\0';
        strcat(tmp, getAudioFilepath());
        setAudioFilepath(tmp);
        delete [] tmp;
        dprintf_full("NEW AUDIO Filepath = %s\n", getAudioFilepath());
        
}

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