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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MP7Parser.hpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: MP7File.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 <expat.h>
#include <stdio.h>
#include <string>
//#include "MP7Time.hpp"

// define at what level (=depth)
// VariationDescriptionType starts
#define VARDESCR_STARTLEVEL             1

#define BUFFSIZE  50000

// errors
#define ERR__OK                         0
#define ERR__NO_VARDESCRTYPE            -1
#define ERR__NO_VARIATIONSET_DEF        -2
#define ERR__SOURCE_OR_VAR_DEF          -3
#define ERR__READ_ERROR                 -4
#define ERR__PARSE_ERROR                        -5
#define ERR__PARSER_CREATE_ERROR                -6
#define ERR__NO_SUCH_VARSET             -7
#define ERR__NO_SUCH_VARIATION          -8
#define ERR__INVALID_DATA               -9
#define ERR__NO_VERTDECOMP              -10
#define ERR__ALLOC                              -11



class MP7Parser {
public:


        class MP7_Sourcedata {
        public:
                std::string id; 
                std::string video_codec;
                bool has_audio;
                std::string audio_codec;
                int video_height;
                int video_width;
                float video_rate;
                std::string fileformat;
                long filesize;
                long bitrate;
                std::string path;
                // constructor
                MP7_Sourcedata();
        };

        class MP7_Variationdata:public MP7_Sourcedata {
        public:
                std::string variation_id;
                float fidelity;
                int priority;
                std::string variation_relationship;
                // constructor
                MP7_Variationdata();
        };

        class MP7_Metadata {
        public:
                std::string title;
                std::string title_image;
                std::string free_text_annotations;
                std::string keywords;
                std::string creator_name;
                std::string location_name;
                std::string location_region;
                std::string date;
                std::string semantic_place;
                std::string semantic_region;
                std::string semantic_time;

                std::string copyright;
                // constructor
                MP7_Metadata();
        };      

        class MP7_MediaTime {
        public:
                std::string mediatimepoint_alpha;
                std::string mediaduration_alpha;
                // constructor
                MP7_MediaTime();
                // returns mediatimepoint as double, converted from string
                double tpAsDouble();
                // returns mediaduration as double, converted from string
                double durAsDouble();
        };

        class MP7_VideoSegmentData {
        public:
                std::string title;
                std::string title_image;
                std::string free_text_annotations;
                std::string keywords;
                MP7_MediaTime mediatime;
                std::string semantic_place;
                std::string semantic_region;
                std::string semantic_time;
                // constructor
                MP7_VideoSegmentData();
        };

        class MP7_VideoSegmentList {
        public:
                MP7_VideoSegmentData vseg_data;
                MP7_VideoSegmentList *next;
                MP7_VideoSegmentList *children;
                // constructor
                MP7_VideoSegmentList();
        };
                
        class MP7_TemporalDecomposition {
        public:
                int errorcode;
                MP7_VideoSegmentList *vseg_list;
                // constructor
                MP7_TemporalDecomposition();
        };      
        
        class MP7_VarList {
        public:
                MP7_Variationdata vdata;
                MP7_VarList *next;
                // constructor
                MP7_VarList();
        };

        class MP7_Variations {
        public:
                int errorcode;
                MP7_VarList *var_list;
                // constructor
                MP7_Variations();
        };

        class MP7_VarSetList {
        public:
                MP7_Sourcedata sdata;
                MP7_Metadata mdata;
                MP7_MediaTime mtime;
                MP7_TemporalDecomposition tmpdec;
                MP7_Variations vdata;
                MP7_VarSetList *next;
                int nr_variations;
                // constructor
                MP7_VarSetList();
                // destructor
        };
        
        class MP7_VarDescrData {
        public:
                int errorcode;
                int nr_varsets;
                MP7_VarSetList *vsl_pointer;
                // constructor
                MP7_VarDescrData();
                // destructor
                ~MP7_VarDescrData();
                // copy constructor
                MP7_VarDescrData(const MP7_VarDescrData & other);
                // assignment operator
                MP7_VarDescrData & operator= (const MP7_VarDescrData & other);
        };


        // open a given filename and return the handle
        static FILE *MP7Open(const char *filename);

        // close a handle
        static bool MP7Close(FILE *fp);

        // main method
        // check MPEG-7 Definition
        // return list of VariationSets, each containing information about
        // Source, Variations, Creation, MediaTime and TemporalDecomposition
        static MP7_VarDescrData MP7GetVarDescrData(FILE *fp);

};

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