vetCodec_MOV.h

#ifndef __VETLIB_VETCODEC_MOV_H__
 #define __VETLIB_VETCODEC_MOV_H__

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

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

// struct quicktime_t;
 extern "C" {
         #include "../../support/quicktime4linux/quicktime.h"
   }




class vetCodec_MOVParameters : public vetCodecParameters
{
        protected:

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

                friend class vetCodec_MOV;


        public:

                vetCodec_MOVParameters();

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

                ~vetCodec_MOVParameters() {  }

                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_MOV :  public vetCodec
 {
        protected:

                vetCodec_MOVParameters* myParams;

                quicktime_t* file;

                unsigned char** buff;

                long lenghtFrames;

                bool streamEOF;

                unsigned int width;

                unsigned int height;

        float outFrameRate;


        public:


                vetCodec_MOV(vetCodec_MOVParameters* initParams = NULL);

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

                ~vetCodec_MOV();

                VETRESULT newVideo(char* filename, unsigned int w, unsigned int h, float frame_rate, int quality = 80);

                VETRESULT save();


                VETRESULT load();

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


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

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


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



                VETRESULT reset();

//              bool EoF() const { return streamEOF; };
                bool EoF();

// FRAME BROWSING FUNCTIONS

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


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

                VETRESULT goToStart();
                VETRESULT goToEnd();

                VETRESULT setVideoFrameRate(float fps);


// VIDEO INFO FUNCTIONS


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

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

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

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

                int getVideoDepth(int stream = 0);

                bool hasVideo();

                int getVideoStreamCount();

                float getVideoFrameRate(int stream = -1);

                long getVideoStreamLength(int stream = -1);

                char* getVideoCompressor(int stream = -1);


// AUDIO INFO FUNCTIONS

                bool hasAudio();

                int getAudioStreamCount();

                int getAudioChannels(int stream = -1);

                long getAudioSampleRate(int stream = -1);

                long getAudioStreamLength(int stream = -1);

                char* getAudioCompressor(int stream = -1);


// MOVIE INFORMATIONS FUNCTIONS

                VETRESULT setName(char *string);
                VETRESULT setInfo(char *string);
                VETRESULT setCopyRight(char *string);

                char* getName();

                char* getInfo();

                char* getCopyRight();





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

};






#endif //__VETLIB_VETCODEC_MOV_H__

---