vetCodec_MPEG.h

#ifndef __VETLIB_VETCODEC_MPEG_H__
 #define __VETLIB_VETCODEC_MPEG_H__

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

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

 #include "../../support/libmpeg3/libmpeg3.h"


 #define VETRET_CODER_FILEOUT_ERR       1010     /*  */
 #define VETRET_CODER_SIZE_ERR          1011     /*  */
 #define VETRET_CODER_WRITE_ERR         1012     /*  */
 #define VETRET_CODER_PALETTE_ERR       1013     /*  */






class vetCodec_MPEGParameters : public vetCodecParameters
{
        protected:

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

                friend class vetCodec_MPEG;


        public:

                vetCodec_MPEGParameters();

                vetCodec_MPEGParameters(const char* filename, int stream = 0, long frameIndex = 0);

                ~vetCodec_MPEGParameters()  {  }

                void reset();

                void setStream(int stream = 0);

                void setFileName(const char *filename);

                void setFrameIndex(long index = 0);


                VETRESULT saveToStreamXML(FILE *fp);

                VETRESULT loadFromStreamXML(FILE *fp);

};






class vetCodec_MPEG :  public vetCodec
 {
        public:


        protected:

                vetCodec_MPEGParameters* myParams;

                mpeg3_t* file;

                unsigned char** buff;           

                char *Y;
                char *U;
                char *V;

                unsigned int width;

                unsigned int height;


        public:


                vetCodec_MPEG(vetCodec_MPEGParameters* initParams = NULL);

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

                ~vetCodec_MPEG();


                VETRESULT save() { return VETRET_NOT_IMPLEMENTED; };
                VETRESULT save(char *filename, int stream = 0) { return VETRET_NOT_IMPLEMENTED; };


                VETRESULT load();


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


                VETRESULT setParameters(vetCodec_MPEGParameters* initParams);

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



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


                VETRESULT reset();

                bool EoF();
//BUG
                bool eof(int stream = -1) const;

// FRAME BROWSING FUNCTIONS

                VETRESULT setFrameIndex(long index, int stream = -1);


                VETRESULT goToPreviousFrame(int stream = -1);

                VETRESULT goToVideoEnd(int stream = -1);

                VETRESULT goToAudioEnd(int stream = -1);


/* Give the seconds time in the last packet read */
                double getLastPacketTime();

//long getAudioFrameIndex(int stream = -1);
//long getVideoFrameIndex(int stream = -1);


// VIDEO INFO FUNCTIONS

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

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


                int getColorModel(int stream = -1);


                bool hasVideo();

                int getVideoStreamCount();

                float getVideoFrameRate(int stream = -1);

                long getVideoStreamLength(int stream = -1);



// AUDIO INFO FUNCTIONS

                bool hasAudio();

                int getAudioStreamCount();

                int getAudioChannels(int stream = -1);

                float getAudioSampleRate(int stream = -1);

                long getAudioStreamLength(int stream = -1);


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

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



                static int getMPEG3_Version_major();
                static int getMPEG3_Version_minor();
                static int getMPEG3_Version_release();





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






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

//              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; };
                bool isDecodingAvailable() { return true; };


};






#endif //__VETLIB_VETCODEC_MPEG_H__

---