vetCodec_BMP2.h

#ifndef __VETLIB_VETCODEC_BMP_H__
 #define __VETLIB_VETCODEC_BMP_H__

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

 #include "../vetFrameYUV420.h"
 #include "../vetFrameRGB24.h"
 #include "../vetFrameT.h"
 #include "../vetFrameRGB96.h"
 #include "../vetFrameRGBA32.h"
 #include "../vetFrameHSV.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_BMPParameters;


class vetCodec_BMP :  protected vetFrameRGB96,
                      public vetCodec
 {

        protected:

                vetCodec_BMPParameters* myParams;

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

                void doFileNameCurrent();

        public:

                enum FileFormat{ FORMAT_BMP_24,
                                                 FORMAT_BMP_RC,
                                                 FORMAT_BMP_MONO,
                                                 FORMAT_BMP_ANY    };



                vetCodec_BMP(vetCodec_BMPParameters* initParams = NULL);

                vetCodec_BMP(vetFrameRGB24& img) : vetFrameRGB96(), vetCodec() {        vetFrameRGB96::operator << (img); reset(); }

                vetCodec_BMP(vetFrameRGB96& img) : vetFrameRGB96(img), vetCodec() { reset(); }

                vetCodec_BMP(unsigned int x, unsigned int y) : vetFrameRGB96(x, y), vetCodec() { reset(); }

                vetCodec_BMP(char* filename, FileFormat format = vetCodec_BMP::FORMAT_BMP_ANY);



                VETRESULT save();

                VETRESULT save(char *filename, int format = vetCodec_BMP::FORMAT_BMP_24);

                VETRESULT load();

                VETRESULT load(char *filename, int format = vetCodec_BMP::FORMAT_BMP_24);


                VETRESULT setParameters(vetCodec_BMPParameters* initParams);

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


                VETRESULT setFilterParameters (vetFilterParameters* initParams);
                vetFilterParameters* getFilterParameters ();


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

                void setFileFormat(FileFormat format = vetCodec_BMP::FORMAT_BMP_24);

                int getFileNameIndex();
                bool isFileNameProgressionEnabled();

                bool isAutoInputEnabled();

                bool isAutoOutputEnabled();

                bool isBufferingEnabled();

                void getFileName(char *filename);

                void getFileNameCurrent(char *filename);

                FileFormat getFileFormat(void);

                VETRESULT reset();


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

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

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

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

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

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

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

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



// 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; }




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

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

                static VETRESULT save(vetFrameRGB96 &source, char *filename, FileFormat format);

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


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

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

                static VETRESULT load(vetFrameRGB96 &source, char *filename, FileFormat format);

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


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

};




class vetCodec_BMPParameters : public vetCodecParameters
{
        protected:

                int fileNameIndex;
                char fileNameBase[128];
                bool fileNameProgression;
                bool autoOuput;
                bool autoInput;
                bool doBuffering;
                vetCodec_BMP::FileFormat fileFormat;


                friend class vetCodec_BMP;


        public:

                vetCodec_BMPParameters();
                vetCodec_BMPParameters(const char* filename, vetCodec_BMP::FileFormat format = vetCodec_BMP::FORMAT_BMP_ANY);
                ~vetCodec_BMPParameters()  {  }

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

                void setFileFormat(vetCodec_BMP::FileFormat format = vetCodec_BMP::FORMAT_BMP_24) { fileFormat = format; };

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

                vetCodec_BMP::FileFormat getFileFormat() { return fileFormat; };


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

};






#endif //__VETLIB_VETCODEC_BMP_H__

---