vetBufferArray.h

#ifndef __VETLIB_VETBUFFERARRAY_H__
 #define __VETLIB_VETBUFFERARRAY_H__

 #include "../vetBuffer.h"


#define VETDEF_STACK_FRAMECOUNT                         100  /*  */
#define VETDEF_STACK_FRAMEREALLOCSTEP           10  /*  */



#define VETDEF_FPS_MAX                  1000  /* maximum number of frames per second */
#define VETDEF_FCOUNT_MAX                       32000  /* maximum number of frames */


template<class T>
class vetBufferArray : public vetBuffer<T>
 {

        protected:

                T** v_frames;           //frames* array

                unsigned int v_current_frame;

                unsigned int v_storageLenght;


        public:

                vetBufferArray() : vetBuffer<T>()
                 {
                        INFO("vetBufferArray::vetBufferArray()  : vetBuffer() [CONTRUCTOR]")
            v_frames = NULL;
                        reset();
                 };

                VETRESULT reset()
                 {
                        INFO("int vetBufferArray::reset() [SET DEFAULT PARAMETERS]")

                        if (v_frames != NULL)
                                delete v_frames;

                        v_frames = NULL;
                        v_fcount = 0;
                        v_storageLenght = VETDEF_STACK_FRAMECOUNT;
                        v_current_frame = 0;
                        copyData = true;

                        return VETRET_OK;
                 };

                ~vetBufferArray()
                 {
                        INFO("vetBufferArray::~vetBufferArray() [DESTRUCTOR]")

            if (v_frames != NULL)
                                delete v_frames;

                 };

                VETRESULT deleteFrames()
                 {
            if (v_frames != NULL)
                         {
                                delete [] v_frames;
                                v_frames = NULL;
                                return reset();
                         }

                        return VETRET_ILLEGAL_USE;
                 };


                VETRESULT addFrame(T* newFrame)
                 {
                        if (v_fcount+1 > VETDEF_FCOUNT_MAX)
                                return VETRET_ILLEGAL_USE;

                        if (v_frames == NULL) // this one will be the first frame
                         {
                                v_storageLenght = VETDEF_STACK_FRAMECOUNT;
                                // allocate a new frames array
                                v_frames = new T*[v_storageLenght]; // first frames array allocation
                                v_fcount = 1;
                                // add the new frame
                                if ( copyData )
                                        v_frames[0] = new T(*newFrame);
                                else
                                        v_frames[0] = newFrame;

                         }
                        else if (v_fcount < (long)v_storageLenght)  // there's enough space for this frame
                         {

                                if ( copyData )
                                        v_frames[v_fcount] = new T(*newFrame);
                                else
                                        v_frames[v_fcount] = newFrame;

                                // update frame count to VetInfo
                                ++v_fcount;

                         }
                        else {
                                // recalculates new storage (array) length using default step size (>1)
                                v_storageLenght = v_fcount + VETDEF_STACK_FRAMEREALLOCSTEP;
                                // allocate a new frames array
                                T** new_frames = new T*[v_storageLenght];
                                // copy frames* to the new array
                                for (int i=0; i<v_fcount; i++) {
                                        new_frames[i] = v_frames[i];
                                 }
                                // remove old pointer and update with new array
                                delete v_frames;
                                v_frames = new_frames;
                                // add the new frame
                                if ( copyData )
                                        v_frames[v_fcount++] = new T(*newFrame);
                                else
                                        v_frames[v_fcount++] = newFrame;
                         }


                        return VETRET_OK;
                 };

                VETRESULT insertFrame(long index, T* newFrame)
                 {
                        if (v_fcount+1 > VETDEF_FCOUNT_MAX)
                                return VETRET_ILLEGAL_USE;

                        if (v_frames == NULL) // this one will be the first frame
                                return addFrame(newFrame);
                        if ( index < 0 || index >= v_fcount)
                                return VETRET_PARAM_ERR;

                        if (v_fcount < (long)v_storageLenght) {  // there's enough space for this frame
                                //move frames* after INDEX one position next
                                for (int i=v_fcount-1; i>=(int)index; i--) {
                                        v_frames[i+1] = v_frames[i];
                                 }
                                //insert the new frame
                                if ( copyData )
                                        v_frames[index] = new T(*newFrame);
                                else
                                        v_frames[index] = newFrame;

                                ++v_fcount;

                         }
                        else {
                                // recalculates new storage (array) length using default step size (>1)
                                v_storageLenght = v_fcount + VETDEF_STACK_FRAMEREALLOCSTEP;
                                // allocate a new frames array
                                T** new_frames = new T*[v_storageLenght];
                                // copy frames* before INDEX to the new array
                                for (int i=0; i<(int)index; i++) {
                                        new_frames[i] = v_frames[i];
                                 }
                                //insert the new frame
                                if ( copyData )
                                        v_frames[index] = new T(*newFrame);
                                else
                                        v_frames[index] = newFrame;
                                // copy frames* after INDEX to the new array
                                for (int j=(int)index; j<v_fcount; j++) {
                                        new_frames[j] = v_frames[j];
                                 }
                                // remove old pointer and update with new array
                                delete v_frames;
                                v_frames = new_frames;
                                // update frame count to VetInfo
                                ++v_fcount;

                        }
                        return VETRET_OK;
                 };

                VETRESULT updateFrame(long index, T* newFrame, bool removeold)
                {
                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;
                        if ( index < 0 || index >= v_fcount )
                                return VETRET_PARAM_ERR;

                        // remove old frame
                        if ( removeold )
                                delete v_frames[ (int)index ];

                        // update frame* with given address
                        if ( copyData )
                                v_frames[index] = new T(*newFrame);
                        else
                                v_frames[index] = newFrame;

                        return VETRET_OK;
                 };

                VETRESULT removeFrame(T* frameToDelete, bool freeData = false)
                 {
                        if (v_frames == NULL)
                                return VETRET_ILLEGAL_USE;

                        int i = 0;
                        while ( i < v_fcount ) {

                                if ( v_frames[i] == frameToDelete )
                                        return removeFrame(i, freeData);
                                i++;
                         }

                        return VETRET_PARAM_ERR;

                 };

                VETRESULT removeFrame(long index, bool freeData = false)
                 {
                        DEBUGMSG("int vetBufferArray::removeFrame(long index)", index)

                        if (v_frames == NULL)
                                return VETRET_ILLEGAL_USE;
                        if ( index < 0 || index >= v_fcount)
                                return VETRET_PARAM_ERR;

                        if ( freeData )
                                delete v_frames[index];

                        //move frames* after INDEX one position back
                        for (int i=(int)index; i<v_fcount-1; i++) {
                                v_frames[i] = v_frames[i+1];
                         }

                        --v_fcount;

                        return VETRET_OK;
                 };


                long getCurrentFrameIndex() const { return v_current_frame; };



                T* getFrame(long index)
                 {
                        if (v_frames == NULL)
                                throw "Buffer is empty.";
                        if ( (int)index < 0 || (int)index >= v_fcount)
                                throw "Index out of range.";

                        return v_frames[ (int)index];
                 };

                T* getCurrentFrame()
                 {
                        if (v_frames == NULL)
                                throw "Video is Empty.";

                        return v_frames[v_current_frame];
                 };

                T* getPreviousFrame()
                 {
                        if (v_frames == NULL)
                                throw "Video is Empty.";
                        if ( v_current_frame < 1 || v_current_frame > (unsigned int)v_fcount)
                                throw "Index out of range.";

                        return v_frames[v_current_frame-1];
                 };

                T* getNextFrame()
                 {
                        if (v_frames == NULL)
                                throw "Video is Empty.";
                        if ( v_current_frame > (unsigned int)v_fcount-2)
                                throw "Index out of range.";

                        return v_frames[v_current_frame+1];
                 };

                T* getFirstFrame()
                 {
                        if ( v_frames == NULL )
                                throw "Video is Empty.";

                        return v_frames[0];
                 };

                T* getLastFrame()
                 {
                        if ( v_frames == NULL )
                                throw "Video is Empty.";

                        return v_frames[v_fcount-1];
                 };

                VETRESULT goToNextFrame()
                 {
                        INFO("int vetBufferArray::goToNextFrame()")

                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        if ( v_current_frame > (unsigned int)v_fcount-2)
                                return VETRET_ILLEGAL_USE;

                        v_current_frame++;

                        return VETRET_OK;
                 };

                VETRESULT goToPreviousFrame()
                 {
                        INFO("")

                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        if ( v_current_frame == 0 )
                                return VETRET_ILLEGAL_USE;

                        v_current_frame--;

                        return VETRET_OK;
                 };

                VETRESULT goToFirstFrame()
                 {
                        INFO("int vetBufferArray::goToFirstFrame()")
                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        v_current_frame = 0;


                        return VETRET_OK;
                 };

                VETRESULT goToLastFrame()
                 {
                        INFO("int vetBufferArray::goToLastFrame()")

                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        v_current_frame = v_fcount-1;


                        return VETRET_OK;
                 };

                VETRESULT goToFrame(long index)
                 {
                        DEBUGMSG("int vetBufferArray::goToFrame(long index)", index)

                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        if ( (int)index < 0 || (int)index >= v_fcount)
                                return VETRET_PARAM_ERR;

                        v_current_frame = (int)index;

                        return VETRET_OK;
                 };

                VETRESULT goToStepFrame(long offset)
                 {
                        DEBUGMSG("int vetBufferArray::goToStepFrame(long offset)", offset)

                        if ( v_frames == NULL )
                                return VETRET_ILLEGAL_USE;

                        if (   ( offset > 0 && v_current_frame + (int)offset < (unsigned int)v_fcount-1)
                                 ||( offset < 0 && v_current_frame + (int)offset > 0)    ) {

                                v_current_frame = v_current_frame + (int)offset;
                                return VETRET_OK;
                         }

                        return VETRET_PARAM_ERR;
                 };




 };


#endif//__VETLIB_VETBUFFERARRAY_H__

---