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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ContainerInfo.hpp

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

#ifndef PS_CONTAINERINFO_HPP
#define PS_CONTAINERINFO_HPP

#ifdef ISOMP4
#include "ISOMovies.h"
#endif
#ifndef WINCE
#include <fcntl.h>
#endif
#include "global.hpp"

#include "Adaptor.hpp"
#include "IO.hpp"
#include "net/Url.hpp"
struct rtx_group;
struct rtx_info;
class MetaObject;
class ESInfo;
class TerminalCapabilities;
class ReferenceCounter;
class VideoESInfo;
class AudioESInfo;

#define MP4CONF_VERSION 7

struct MetaItem {
        MetaItem(u32 es, float q, u32 s, Adaptor * a) {
                quality = q;
                esId = es;
                size = s;
                adapt = a;
        };
        ~MetaItem() {
                if (adapt)
                        delete adapt;
        }
        Adaptor *getClonedAdaptor() {
                if (adapt)
                        return adapt->clone();
                else
                        return NULL;
        };
        MetaItem *clone() {
                return new MetaItem(esId, quality, size, getClonedAdaptor());
        };

        float quality;
        u32 size;
        Adaptor *adapt;
        u32 esId;
};

struct QualityInfo {
        QualityInfo(u32 size, u8 maxSteps = 5) {
                lastRequestTime = 0;
                currentQAStep = 0;
                maxQASteps = 1;
                stepLimit = maxSteps;
                steps = new MetaItem *[stepLimit];
                // init array to NULL
                memset((char*)steps,0,sizeof(MetaItem*)*stepLimit);
                // the first entry is the original video, no need for a real Adaptor
                steps[currentQAStep] = new MetaItem(0, 1.0, size, NULL);
        };
        QualityInfo(QualityInfo & qi) {
                lastRequestTime = 0;
                currentQAStep = qi.currentQAStep;
                maxQASteps = qi.maxQASteps;
                stepLimit = qi.stepLimit;
                steps = new MetaItem *[stepLimit];
                for (int i = 0; i < maxQASteps; i++)
            steps[i] = qi.steps[i]->clone();
        };
        ~QualityInfo() {
                for (int i = 0; i < maxQASteps; i++) {
            if(steps[i])
                                delete steps[i];
                }
                delete[] steps;
        };
        bool addMetaItem(MetaItem * m) {
                if (maxQASteps >= stepLimit)
            return false;
                steps[maxQASteps] = m;
                maxQASteps++;
                return true;
        }
        u32 lastRequestTime;
        MetaItem **steps;
        u8 currentQAStep;
        u8 maxQASteps;
        u8 stepLimit;
        u32 esInfoId;
};


class ContainerInfo {
public:

        typedef enum { UNKNOWN_CONTAINER, AVI, MP4, MATROSKA, VITOOKI, DVD, SDP, OGG} ContainerType;


        ContainerInfo(const char *url, const char* locFile, const ContainerType type);
        ContainerInfo();
        
        ContainerInfo(QualityInfo & q);
        
        virtual ~ ContainerInfo();
        
        list < ESInfo * >* getESList() {
                return &esList;
        };
        
        ESInfo *getES(u32 streamId) const;
        
        VideoESInfo *getFirstVisualES();
        
        u32 getNumberOfVisualStreams() const;

        u32 getNumberOfAudioStreams() const;

        AudioESInfo *getFirstAudioES();

        /* @returns the type from the enumeration like MP4, DVD or SDP  */
        ContainerType getContainerType() { return type; };

        /* sets the container type 
         * @param ctype:  enumeration like MP4, DVD or SDP  */
        void setContainerType(ContainerType ctype) { type=ctype; };

        IO *getMuxDemuxIO() { return muxDemuxIO; };

        void setMuxDemuxIO(IO *demuxio) { muxDemuxIO = demuxio; };

        bool saveToCfgFile(char *indexName);
        
        bool loadFromCfgFile(char *indexName);
        
  const Url *getUrl() const;
        
        /* shallow copies url */
  void setUrl(Url *uri);
        
        /* deep copies loclFile */
        void setLocalFile(const char* loclFile);
        
        const char* getLocalFile() const {
                return localFile;
        }
        
        void setIODHandle(u8 * iodHandle, u32 iodHandleSize);
        
        const u8 *getIODHandle(u32 & size) const {
                size = iodHandleSize;
                return iodHandle;
        };
        
        void addESInfo(ESInfo * esobj) {
                esList.push_back(esobj);
        };
        
        inline u32 getActSize() const {
                return qinfo.steps[qinfo.currentQAStep]->size;
        };

        inline float getActQuality() const {
                return qinfo.steps[qinfo.currentQAStep]->quality;
        };
        
        u32 getLastRequestTime() const {
                return lastAccessTime;
        };

        void setLastRequestTime(u32 last) {
                lastAccessTime = last;
        };
        
        u32 getFileSize() const;

        u32 getEstimatedNetworkFileSize();

        void setMetaObject(MetaObject* meta);

        MetaObject* getMetaObject();
        
        bool hasAudio()const;
        
        QualityInfo *getQualityInfo() {
                return &qinfo;
        };
        ContainerInfo * clone();
        
        ReferenceCounter* getUsageCounter();

        bool destroy();

        rtx_group* getRtxGroup(u32 esId,list<rtx_group*>* rtxInfo) const;


private:
        void clear();
        ESInfo *parseES(char *line);


protected:
        ContainerType type;

        list < ESInfo * >esList;

        IO *muxDemuxIO;

  Url *url;

        char *localFile; 

        MetaObject* metaObj;

        u8 *iodHandle;

        u32 iodHandleSize;

        u32 timeScale;

        u32 lastAccessTime;

        ReferenceCounter* usageCounter;

        QualityInfo qinfo;

        /* Name of the video */
        char *Name;
        
        /* Description of the Video's content */
        char *Description;
        
        /* Video's MimeType */
        char *MimeType;
};

#endif

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