vetCodec_IMG.h

#ifndef __VETLIB_VETCODEC_IMG_H__
 #define __VETLIB_VETCODEC_IMG_H__

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

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


#define VETRET_CODER_FILEOUT_ER 1010     /*  */
#define VETRET_CODER_SIZE_ER    1011     /*  */
#define VETRET_CODER_WRITE_ER   1012     /*  */
#define VETRET_CODER_PALETTE_ER 1013     /*  */






class vetCodec_IMGParameters : public vetCodecParameters
{
        protected:

                int fileNameIndex;
                char fileNameBase[128];
                bool fileNameProgression;
                bool autoOuput;
                bool autoInput;
                bool doBuffering;


                friend class vetCodec_IMG;


        public:

                vetCodec_IMGParameters();
                vetCodec_IMGParameters(char* filename);
                ~vetCodec_IMGParameters()  {  }

                void reset();


                void setFileNameIndex(int base = -1) { fileNameIndex = base; };

                void setFileNameProgression(bool value = true) { fileNameProgression = value; };

                void setAutoOutputEnabled(bool value = true) { autoOuput = value; };

                void setAutoInputEnabled(bool value = true) { autoInput = value; };

                void setDoBuffering(bool value = true) { doBuffering = value; };

                void setFileName(const char *filename);

                int getFileNameIndex() { return fileNameIndex;};
                bool isFileNameProgressionEnabled() { return fileNameProgression; };

                bool isAutoInputEnabled() { return autoInput;};

                bool isAutoOutputEnabled() { return autoOuput;};

                bool isBufferingEnabled() { return doBuffering;};

                void getFileName(char *filename);

                void getFileNameCurrent(char *filename);



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

};




class vetCodec_IMG :  public vetCodec
 {
        public:


        protected:

                vetCodec_IMGParameters* myParams;

            unsigned int width ;
            unsigned int height ;
            void         *img ;
            bool         ok ;


                char fileNameIndexBuffer[16];
                char fileNameBuffer[80];

                void doFileNameCurrent();


static void* im_load(char *filename, unsigned int &w, unsigned int &h, char* prog_path) ;
static void im_get_data(void *image, int *rgb) ;
static void im_get_data(void *img, unsigned char *rgb);

static void im_get_data_grey(void *image, int *d) ;
static void im_free(void *img) ;


        public:


                vetCodec_IMG(vetCodec_IMGParameters* initParams = NULL);

                vetCodec_IMG(char* filename);



                VETRESULT save();

                VETRESULT save(char *filename);

                VETRESULT load();

                VETRESULT load(char *filename);


                VETRESULT setParameters(vetCodec_IMGParameters* initParams);

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


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

                bool EoF();

                void setFileNameProgression(bool value);

                void setAutoOutputEnabled(bool value = true);

                void setAutoInputEnabled(bool value = true);

                void setDoBuffering(bool value = true);

                void setFileName(const char *filename);


                int getFileNameIndex();
                bool isFileNameProgressionEnabled();

                bool isAutoInputEnabled();

                bool isAutoOutputEnabled();

                bool isBufferingEnabled();

                void getFileName(char *filename);

                void getFileNameCurrent(char *filename);


                VETRESULT reset();


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

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

                VETRESULT setHeight(unsigned int value) { return VETRET_NOT_IMPLEMENTED; };

                VETRESULT setWidth(unsigned int value) { return VETRET_NOT_IMPLEMENTED; };


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

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

                bool hasAudio() { return false; };
                bool hasVideo() { return false; };

                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);




                static VETRESULT save(vetFrameYUV420 &source, const char *filename);

                static VETRESULT save(vetFrameRGB24 &source, const char *filename);

                static VETRESULT save(vetFrameT<unsigned char> &source, const char *filename);


                static VETRESULT load(vetFrameYUV420 &source, const char *filename);

                static VETRESULT load(vetFrameRGB24& source, const char *filename);

                static VETRESULT load(vetFrameT<unsigned char>& source, const char *filename);


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

};






#endif //__VETLIB_VETCODEC_IMG_H__

---