vetMultiplexer.cpp

Go to the documentation of this file.

#include "vetMultiplexer.h"


vetMultiplexer::vetMultiplexer(vetMultiplexerParameters* initParams) : vetFilter()
 {
        INFO("vetMultiplexer::vetMultiplexer(..* initParams) : vetFilter() [CONTRUCTOR]")

        inputs = NULL;
        outputs = NULL;

        reset();

        setParameters(initParams);
 }

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

        delete inputs;  // removes array only, not objects
        delete outputs; // removes array only, not objects

        if (myParams != NULL)
                delete myParams;
        myParams = NULL;
 }

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

        setName("Multiplexer");
        setDescription("Link some sources with some outputs");
        setVersion(1.0);

        if ( inputs != NULL )
                delete inputs;

        if ( outputs != NULL )
                delete outputs;

        inputs = new vetInput*[VET_MP_INPUTS_MAX];
        outputs = new vetOutput*[VET_MP_OUTPUTS_MAX];

        for (int i=0; i<VET_MP_INPUTS_MAX; i++)
                inputs[i] = NULL;
        for (int j=0; j<VET_MP_OUTPUTS_MAX; j++)
                outputs[j] = NULL;

        inputCurrent = 0;
        outputCurrent = 0;
        inputCount = 0;
        outputCount = 0;

        return VETRET_OK;
 }


VETRESULT vetMultiplexer::setParameters (vetMultiplexerParameters* initParams)
 {
        if ( initParams == NULL )
                myParams = new vetMultiplexerParameters();
        else
                myParams = initParams;

        return VETRET_OK;
 }










//TODO
//should be managed as thread!!
VETRESULT vetMultiplexer::run(long cycles)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::run(long cycles)", cycles)

        if ( inputs[inputCurrent] == NULL || outputs[outputCurrent] == NULL )
                return VETRET_ILLEGAL_USE;

        if ( cycles == 0)
                cycles = VET_MP_LOOP_MAX;

        if ( isBufferYUV() )
         {
                for (long i=0; i < cycles; i++)
                 {
                        *inputs[inputCurrent] >> *bufferYUV;
                        *outputs[outputCurrent] << *bufferYUV;
                 }
         }

        else if ( isBufferRGB() )
         {
                for (long i=0; i < cycles; i++)
                 {
                        *inputs[inputCurrent] >> *bufferRGB;
                        *outputs[outputCurrent] << *bufferRGB;
                 }
         }

        else
         {
                for (long i=0; i < cycles; i++)
                 {
                        *inputs[inputCurrent] >> *bufferTuC;
                        *outputs[outputCurrent] << *bufferTuC;
                 }
         }

        return VETRET_OK;
 }















VETRESULT vetMultiplexer::importFrom(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::importFrom(vetFrameYUV420& img) [reading data]", outputCurrent)

        *outputs[outputCurrent] << img;
        return VETRET_OK;
 }

VETRESULT vetMultiplexer::importFrom(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::importFrom(vetFrameRGB24& img) [reading data]", outputCurrent)

        *outputs[outputCurrent] << img;
        return VETRET_OK;
 }

VETRESULT vetMultiplexer::importFrom(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::importFrom(vetFrameT& img) [reading data]", outputCurrent)

        *outputs[outputCurrent] << img;
        return VETRET_OK;
 }

VETRESULT vetMultiplexer::extractTo(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::extractTo(vetFrameYUV420& img) [pushing data]", inputCurrent)

        *inputs[inputCurrent] >> img;
        return VETRET_OK;
 }

VETRESULT vetMultiplexer::extractTo(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::extractTo(vetFrameRGB24& img) [pushing data]", inputCurrent)

        *inputs[inputCurrent] >> img;
        return VETRET_OK;
 }

VETRESULT vetMultiplexer::extractTo(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::extractTo(vetFrameT& img) [pushing data]", inputCurrent)

        *inputs[inputCurrent] >> img;
        return VETRET_OK;
 }





VETRESULT vetMultiplexer::addInput(vetInput* newInput)
{
        DEBUGMSG("VETRESULT vetMultiplexer::addInput(vetInput* newInput)", inputCount)

        if ( newInput == NULL )
                return VETRET_PARAM_ERR;

        if ( inputCount >= VET_MP_INPUTS_MAX )
                return VETRET_ILLEGAL_USE;

        inputs[inputCount++] = newInput;

        return VETRET_OK;
}

VETRESULT vetMultiplexer::removeInput(vetInput* oldInput)
{
        DEBUGMSG("VETRESULT vetMultiplexer::removeInput(vetInput* oldInput)", inputCount)

        if ( oldInput == NULL )
                return VETRET_PARAM_ERR;

        int iter = 0;
        while ( iter < inputCount )
         {
                if ( inputs[iter] == oldInput )
                        return removeInput(iter);
                iter++;
         }

        return VETRET_OK;
}

VETRESULT vetMultiplexer::removeInput(int id)
{
        DEBUGMSG("VETRESULT vetMultiplexer::removeInput(int id)", id)

        if ( id < 0 || id >= inputCount )
                return VETRET_PARAM_ERR;

        //move * after ID one position back
        for (int i=id; i<inputCount-1; i++) {
                inputs[i] = inputs[i+1];
         }

        inputs[inputCount--] = NULL;

        return VETRET_OK;
}

VETRESULT vetMultiplexer::addOutput(vetOutput* newOutput)
{
        DEBUGMSG("VETRESULT vetMultiplexer::addOutput(vetOutput* newOutput)", outputCount)

        if ( newOutput == NULL )
                return VETRET_PARAM_ERR;

        if ( outputCount >= VET_MP_OUTPUTS_MAX )
                return VETRET_ILLEGAL_USE;

        outputs[outputCount++] = newOutput;

        return VETRET_OK;
}

VETRESULT vetMultiplexer::removeOutput(vetOutput* oldOutput)
{
        DEBUGMSG("VETRESULT vetMultiplexer::removeOutput(vetOutput* oldOutput)", outputCount)

        if ( oldOutput == NULL )
                return VETRET_PARAM_ERR;

        if ( outputCount >= VET_MP_OUTPUTS_MAX )
                return VETRET_ILLEGAL_USE;

        int iter = 0;
        while ( iter < outputCount )
         {
                if ( outputs[iter] == oldOutput )
                        return removeOutput(iter);
                iter++;
         }

        return VETRET_PARAM_ERR;
}

VETRESULT vetMultiplexer::removeOutput(int id)
{
        DEBUGMSG("VETRESULT vetMultiplexer::removeOutput(int id)", id)

        if ( id < 0 || id >= outputCount )
                return VETRET_PARAM_ERR;

        //move * after ID one position back
        for (int i=id; i<outputCount-1; i++) {
                outputs[i] = outputs[i+1];
         }

        outputs[outputCount--] = NULL;

        return VETRET_OK;
}

VETRESULT vetMultiplexer::setCurrentInput(int id)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::setCurrentInput(int id)", id)

        if ( id < 0 || id >= inputCount )
                return VETRET_PARAM_ERR;

        if ( inputs[id] == NULL )
                return VETRET_PARAM_ERR;

        inputCurrent = id;

        return VETRET_OK;
 }

VETRESULT vetMultiplexer::setCurrentInput(vetInput& currIn)
 {
        INFO("VETRESULT vetMultiplexer::setCurrentInput(vetInput& currSource)")

        if ( &currIn == NULL )
                return VETRET_PARAM_ERR;

        int iter = 0;
        while ( iter < inputCount )
         {
                if ( inputs[iter] == &currIn ) {
                        inputCurrent = iter;
                        return VETRET_OK;
                 }
                iter++;
         }

        return VETRET_PARAM_ERR;
 }

VETRESULT vetMultiplexer::setCurrentOutput(int id)
 {
        DEBUGMSG("VETRESULT vetMultiplexer::setCurrentOutput(int id)", id)

        if ( id < 0 || id >= outputCount )
                return VETRET_PARAM_ERR;

        if ( outputs[id] == NULL )
                return VETRET_PARAM_ERR;

        outputCurrent = id;

        return VETRET_OK;
 }

VETRESULT vetMultiplexer::setCurrentOutput(vetOutput& currOut)
 {
        INFO("VETRESULT vetMultiplexer::setCurrentOutput(vetOutput& currOut)")

        if ( &currOut == NULL )
                return VETRET_PARAM_ERR;

        int iter = 0;
        while ( iter < outputCount )
         {
                if ( outputs[iter] == &currOut ) {
                        outputCurrent = iter;
                        return VETRET_OK;
                 }
                iter++;
         }

        return VETRET_PARAM_ERR;
 }










vetMultiplexerParameters::vetMultiplexerParameters()
 {

 }

void vetMultiplexerParameters::reset()
 {
        runMode = 0;
 }


int vetMultiplexerParameters::saveToStreamXML(FILE *fp)
 {
        return VETRET_NOT_IMPLEMENTED;
 }


int vetMultiplexerParameters::loadFromStreamXML(FILE *fp)
 {
        return VETRET_NOT_IMPLEMENTED;
 }

---