vetMultiplexer.h

#ifndef __VETLIB_VETMULTIPLEXER_H__
 #define __VETLIB_VETMULTIPLEXER_H__

 #include "../vetDefs.h"
 #include "../vetFilter.h"

 #include "../vetThread.h"

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


 #define VET_MP_INPUTS_MAX              12
 #define VET_MP_OUTPUTS_MAX             12

 #define VET_MP_LOOP_MAX                1000000


class vetMultiplexerParameters : public vetFilterParameters
{
        protected:

                int runMode;

                friend class vetMultiplexer;


        public:


                vetMultiplexerParameters();
                ~vetMultiplexerParameters() {}

                void reset();

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

};

class vetMultiplexer :  public vetFilter
 {

 protected:

                vetMultiplexerParameters* myParams;


                vetInput** inputs;
                int inputCount;

                vetOutput** outputs;
                int outputCount;

                int inputCurrent;
                int outputCurrent;


 public:


                vetMultiplexer( vetMultiplexerParameters* initParams = NULL );

                ~vetMultiplexer();

                float getFrameRate()  const { return 0; };


                VETRESULT setParameters(vetMultiplexerParameters* initParams);

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

                VETRESULT setFilterParameters (vetFilterParameters* initParams)
                 {
                        if (initParams == NULL)
                                return setParameters(NULL);
                        else
                                return setParameters(static_cast<vetMultiplexerParameters*>(initParams));
                 };



                vetFilterParameters* getFilterParameters ()
                 {
                        if (myParams == NULL)
                                return NULL;
                        else
                                return static_cast<vetFilterParameters*>(myParams);
                 };

                VETRESULT reset();

                VETRESULT run(long cycles = 0);

                VETRESULT stop();



                VETRESULT forward() { return run(1); };


                VETRESULT addInput(vetInput* newInput);

                VETRESULT removeInput(vetInput* oldInput);
                VETRESULT removeInput(int id);

                VETRESULT addOutput(vetOutput* newOutput);

                VETRESULT removeOutput(vetOutput* oldOutput);
                VETRESULT removeOutput(int id);

                VETRESULT setCurrentInput(int id);
                VETRESULT setCurrentInput(vetInput& currIn);

                VETRESULT setCurrentOutput(int id);
                VETRESULT setCurrentOutput(vetOutput& currOut);

                int getCurrentInputId() { return inputCurrent; };
                vetInput* getCurrentInput() { return inputs[inputCurrent]; };

                int getCurrentOutputId() { return outputCurrent; };
                vetOutput* getCurrentOutput() { return outputs[outputCurrent]; };

                int getInputCount() { return inputCount; };
                int getOutputCount() { return outputCount; };


                VETRESULT importFrom(vetFrameYUV420& img);

                VETRESULT importFrom(vetFrameRGB24& img);

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


                VETRESULT extractTo(vetFrameYUV420& img);

                VETRESULT extractTo(vetFrameRGB24& img);

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


};



#endif //__VETLIB_VETMULTIPLEXER_H__

---