vetFilter.h

#ifndef __VETLIB_VETFILTER_H__
 #define __VETLIB_VETFILTER_H__

 #include "vetDefs.h"
 #include "vetObject.h"

 #include "vetInput.h"
 #include "vetOutput.h"

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


 #include <stdio.h>
 #include <fstream>


class vetFilterParameters
 {
        public:

                enum BUFFER_TYPE { NONE, YUV, RGB, TuC };

        protected:

                BUFFER_TYPE currentBuffer;

                friend class vetFilter;

        public:

                vetFilterParameters() {};//{ reset(); }

                virtual ~vetFilterParameters() {}

//              virtual void reset() = 0;


                VETRESULT saveToXML(const char* filename);

                VETRESULT loadFromXML(const char* filename);



                virtual VETRESULT saveToStreamXML(FILE *fp) = 0;

                virtual VETRESULT loadFromStreamXML(FILE *fp) = 0;

 };









class vetFilter :       public vetInput,
                                        public vetOutput,
                                        public vetObject
 {

        protected:

                vetFrameYUV420* bufferYUV;

                vetFrameRGB24* bufferRGB;

                vetFrameT<unsigned char>* bufferTuC;


                void allocateBuffer(vetFilterParameters::BUFFER_TYPE bType);

                void releaseBuffers();

        public:


                vetFilter(float fps = 0);


                ~vetFilter();



                virtual VETRESULT setFilterParameters (vetFilterParameters* initParams) = 0;



                virtual vetFilterParameters* getFilterParameters () = 0;



                virtual VETRESULT reset() = 0;



                vetFrameYUV420* dump_buffer_YUV() { return bufferYUV; };

                vetFrameRGB24* dump_buffer_RGB() { return bufferRGB; };

                vetFrameT<unsigned char>* dump_buffer_TuC() { return bufferTuC; };

                void useBufferYUV(unsigned int width, unsigned int height);

                void useBufferRGB(unsigned int width, unsigned int height);

                void useBufferTuC(unsigned int width, unsigned int height, vetFrame::VETFRAME_PROFILE profile);

                bool isBufferYUV() { if ( bufferYUV != NULL ) return true; return false; };

                bool isBufferRGB() { if ( bufferRGB != NULL ) return true; return false; };

                bool isBufferTuC() { if ( bufferTuC != NULL ) return true; return false; };


                VETRESULT setHeight(unsigned int value);

                VETRESULT setWidth(unsigned int value);

                unsigned int getWidth() const;


                unsigned int getHeight() const;


                bool EoF();



                VETRESULT extractTo(vetFrameYUV420& img);

                VETRESULT extractTo(vetFrameRGB24& img);

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



                virtual VETRESULT importFrom(vetFrameYUV420& img) = 0;

                virtual VETRESULT importFrom(vetFrameRGB24& img) = 0;

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



                enum{ vetClassType = VETCLASS_TYPE_FILTER };

};



#endif //__VETLIB_VETFILTER_H__

---