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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

ESInfo.hpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:   ESInfo.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_ELEMENTARYSTREAMINFO_HPP
#define PS_ELEMENTARYSTREAMINFO_HPP


#include "global.hpp"
#include <assert.h>

#ifdef ISOMP4
#include "ISOMP4ContainerFile.hpp"
#include "ISOMovies.h"
#include "avformat.h"
#else
//#include "ffMP4ContainerFile.hpp"
#ifdef __cplusplus
extern "C" {
#include "avformat.h"
}
#endif
#endif

class ContainerInfo;
class BitField;
class ReferenceCounter;


class ESInfo {
public:
        ESInfo(u64 streamId, u32 streamtype, ContainerInfo * vob, u32 timeIncrement,
                                 u8 * encodeddecconf, u32 objtype, u32 bufsize,
                                 u32 avg, u32 maxBand, u32 timeScale,
                                 u64 duration, u32 size,  bool complete=true, 
                                 CodecID codec_id = CODEC_ID_NONE, float quality = 1.0);
        
        virtual ~ESInfo();
        
        u32 getHeaders(u8 **pHeaders) const;

        u64 getStreamId() const {
                return streamId;
        };

        const u8 *getEncodedDecoderConfig() const {
                return encodedDecoderConfig;
        };

        virtual void setEncodedDecoderConfig(u8 * enc);

        void setDecoderConfig(const u8 * dec, int size);

        u32 getObjectType() const {
                return objectType;
        };

        u32 getStreamType() const { 
                return streamType;
        };

        u32 getBufferSize() const {
                return bufferSize;
        };

/*      bool openSucceeded() const {
                return handlerType != (u32) - 1;
        }; */
        virtual u32 getHandlerType() const=0;

        virtual bool isVisualStream() const=0;

        virtual bool isAudioStream() const=0;

        virtual bool isODStream() const=0;

        virtual bool isSceneDescriptionStream() const=0;

        virtual void generateDescriptionText() { strcpy(description,"Generic ESInfo");};
        
        const char *getDescriptionText() const { return description;};
        
        virtual ESInfo *clone(ContainerInfo * mp4)=0;

        bool getCompleteState() const;

        float getStreamQuality() const { return quality;};

        void setCompleteState(bool comp) {
                complete=comp;
        }
        
        void setInput(const char *inp);

        const char *getInput() const {
                return input;
        };

        /* @returns avg BW in Bits/sec */
        u32 getAvgBandwidth() const {
                return avgBandwidth;
        };
        void setAvgBandwidth(u32 uiBandwidth) {
                avgBandwidth = uiBandwidth;
        };
        u32 getMaxBandwidth() const {
                return maxBandwidth;
        };
        void setMaxBandwidth(u32 uiMaxBandwidth) {
                maxBandwidth = uiMaxBandwidth;
        };
        u32 getMediaTimeScale() const {
                return mediaTimeScale;
        };
        void setMediaTimeScale(u32 uiMediaTimeScale) {
                assert(uiMediaTimeScale>0);
                mediaTimeScale = uiMediaTimeScale;
        };

        u64 getDuration() const {
                return duration;
        };
        void setDuration(u64 uiDuration);

        u64 getDurationInMs() const {
                return (duration * 1000) / mediaTimeScale;
        };
        u32 getOrigMediaSize() const {
                return mediaSize;
        };

        void setOrigMediaSize(u32 mediaSize) {
                this->mediaSize = mediaSize;
        };

        u32 getCurrentDemuxedMediaSize() const;

        u32 getFrameNumber(double timeInSeconds, bool upround = true) const;
        
  double getMediaTime(u32 frameNo) const;

        void setVOPTimeIncrement(u32 ticks);

        u32 getVOPTimeIncrement() const {
                return vopTimeIncrement;
        };
        
        u32 getNumberOfMediaSamples() const {
                if(vopTimeIncrement==0)
                        return 0;
                return (duration/vopTimeIncrement);
        };
        
        ContainerInfo *getContainerInfo() {
                return vo;
        };
        
        bool getDecConfUpdated() const { return decConfUpdated;};

        void clearDecConfUpdated() { decConfUpdated=false;};
        
        bool enableFrameStatistic();

        /* frees an existing frame statistics object */
        void disableFrameStatistic();

        BitField* getFrameStatistic();

        void setFrameStatistic(BitField*);

        ReferenceCounter* getUsageCounter() { return usageCounter;};

        void setCloneCounter( ReferenceCounter* &ref);

        ReferenceCounter* getCloneCounter() { return existingClones;}

        void setCodecID(CodecID id) {
                codec_id = id;
        }
        
        CodecID getCodecID() {
                return codec_id;
        }

        bool destroy();

protected:
        u64 streamId;
        u32 streamType;
        ContainerInfo *vo;
        char *input;
        u8 *encodedDecoderConfig;
        u32 objectType;
        u32 bufferSize;
        u32 avgBandwidth;
        u32 maxBandwidth;
        u32 mediaTimeScale;
        u64 duration;
        u32 mediaSize;
        u32 vopTimeIncrement;
        bool decConfUpdated;
        bool complete;
        BitField* frameStatistic;
        ReferenceCounter* usageCounter;
        ReferenceCounter* existingClones;
        CodecID codec_id;
        /* the quality of stream as determined by ffmpeg 
         * Its a value between 1(good) and 31(bad)
         * Needed for transcoding.
         */
        float quality;
        char description[MAX_STR_LEN];
        
        /* Language spoken or displayed in either audio or video */
        char *Language;

private:
        bool loadInfo(char *file);
        
};

#endif

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