vetCodec_XVID.h

#ifndef __VETLIB_VETCODEC_XVID_H__
 #define __VETLIB_VETCODEC_XVID_H__

 #include "../vetDefs.h"
 #include "../vetCodec.h"

 #include "../vetFrameYUV420.h"
 #include "../vetFrameRGB24.h"
 #include "../vetFrameT.h"



 #include "../../support/xvidcore/src/xvid.h"



 #define BUFFER_SIZE (2*1024*1024)





class vetCodec_XVIDParameters : public vetCodecParameters
{
        protected:

                char fileName[64];
                long frameIndex;
                int stream;

                friend class vetCodec_XVID;


        public:

                vetCodec_XVIDParameters();
                vetCodec_XVIDParameters(const char* filename, int stream = 0, long frameIndex = 0);
                ~vetCodec_XVIDParameters() {  }

                void reset();

                void setStream(int stream);
                void setFileName(const char *filename);
                void setFrameIndex(long index = 0);

                VETRESULT saveToStreamXML(FILE *fp);
                VETRESULT loadFromStreamXML(FILE *fp);

};


class vetCodec_XVID :  public vetCodec
 {

        protected:

                void *stream_handle;

                unsigned char *mp4_buffer;
                unsigned char *mp4_ptr;

                unsigned char *buffer;

                FILE* file;

                int use_assembler;
                int debug_level;

                int useful_bytes;
                int chunk;
                xvid_dec_stats_t xvid_dec_stats;

                double totaldectime;

                long totalsize;
                int status;

                int filenr;


                vetCodec_XVIDParameters* myParams;


                unsigned int width;             
                unsigned int height;            

                VETRESULT doDecodeFrame();

                VETRESULT init();
                VETRESULT close();
                VETRESULT flush();
                VETRESULT release();

                VETRESULT updateBuffer(unsigned int width, unsigned int height);

                VETRESULT dec_init(int use_assembler, int debug_level);
                VETRESULT dec_main(unsigned char *istream, unsigned char *ostream, int istream_size, xvid_dec_stats_t *xvid_dec_stats);

                VETRESULT write_image(char *prefix, unsigned char *image);
                VETRESULT write_pnm(char *filename, unsigned char *image);


        public:


                vetCodec_XVID(vetCodec_XVIDParameters* initParams = NULL);

                vetCodec_XVID(char* filename, int stream = 0);


                ~vetCodec_XVID();



                VETRESULT setParameters(vetCodec_XVIDParameters* initParams);

                vetCodec_XVIDParameters& getParameters() { return *myParams; };


                VETRESULT setFilterParameters (vetFilterParameters* initParams) { return setParameters(static_cast<vetCodec_XVIDParameters*>(initParams)); };
                vetFilterParameters* getFilterParameters () { return static_cast<vetFilterParameters*>(myParams); };


                VETRESULT save();


                VETRESULT load();

                VETRESULT load(char *filename, int stream = 0);


                VETRESULT save(char *filename, int stream = 0);


                VETRESULT reset();

                bool EoF();


                VETRESULT extractTo(vetFrameYUV420& img);

                VETRESULT extractTo(vetFrameRGB24& img);

                VETRESULT extractTo(vetFrameT<unsigned char>& img);



                VETRESULT importFrom(vetFrameYUV420& img);

                VETRESULT importFrom(vetFrameRGB24& img);

                VETRESULT importFrom(vetFrameT<unsigned char>& img);




// FRAME BROWSING FUNCTIONS

/*
                VETRESULT setFrameIndex(long index, int stream = 0);

                bool eof(int stream = 0) const;

                VETRESULT goToPreviousFrame(int stream = 0);

                VETRESULT goToVideoEnd(int stream = 0);
                VETRESULT goToAudioEnd(int stream = 0);
*/
/* Give the seconds time in the last packet read */
                double getLastPacketTime();


// VIDEO INFO FUNCTIONS

                unsigned int getHeight() const { return height; };

                unsigned int getWidth() const { return width; };

                long getVideoStreamLength(int stream = 0) { return totalsize; };
                long getAudioStreamLength(int stream = -1) { return -1; };

                int getVideoStreamPosition(int stream = 0) { return filenr; };

                double getVideoStreamDecodedTotalTime(int stream = 0) { return totaldectime; };

                bool hasAudio(int stream = -1) { return false; };
                bool hasVideo(int stream = -1) { return false; };


                int getAudioStreamCount(int stream = -1) { return -1; };
                int getVideoStreamCount(int stream = -1) { return -1; };




//              float getVideoFrameRate(int stream = -1) ;








/*
                int getColorModel(int stream = 0);


                bool hasVideo();



                float getVideoFrameRate(int stream = 0);




// AUDIO INFO FUNCTIONS

                bool hasAudio();


                int getAudioChannels(int stream = 0);

                float getAudioSampleRate(int stream = 0);

                long getAudioStreamLength(int stream = 0);






                int getXVID3_Version_major() { return mpeg3_major(); };
                int getXVID3_Version_minor() { return mpeg3_minor(); };
                int getXVID3_Version_release() { return mpeg3_release(); };

*/

                // decode all stream !
                VETRESULT doDecode(long frameCount = 0);

                VETRESULT setHeight(unsigned int value)
                 {
                        height = value;
                        return VETRET_OK;
                 };

                VETRESULT setWidth(unsigned int value)
                 {
                        width = value;
                        return VETRET_OK;
                 };


// call importFrom, so filename index is managed

//              void operator << (vetFrameYUV420& img) { vetOutput::operator << (img); }
//              void operator << (vetFrameRGB24& img) { vetOutput::operator << (img); }
//              void operator << (vetFrameT<unsigned char>& img) { vetOutput::operator << (img); }

// call extractTo, so filename index and frame rate are managed

//              vetInput& operator >> (vetFrameYUV420& img) { vetInput::operator >> (img); return *this; }
//              vetInput& operator >> (vetFrameRGB24& img) { vetInput::operator >> (img); return *this; }
//              vetInput& operator >> (vetFrameT<unsigned char>& img) { vetInput::operator >>( img); return *this; }


                bool isEncodingAvailable() { return false; }; //{ return true; };
                bool isDecodingAvailable() { return true; };


};







#endif //__VETLIB_VETCODEC_XVID_H__

---