vetCodec_IMG.cpp

Go to the documentation of this file.

#include "vetCodec_IMG.h"


#include <string.h>     // memcpy
#include <stdlib.h> // itoa()


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>


#include <sys/types.h>


#include <magick/api.h>


void* vetCodec_IMG::im_load(char *filename, unsigned int &w, unsigned int &h, char* prog_path)
 {
        Image *image ;
        ExceptionInfo exception;

        ImageInfo *image_info;

        /*
        Initialize the image info structure and read an image.
        */
        InitializeMagick(prog_path); // Should really pass argv[0] (only req'd under windows)
        GetExceptionInfo(&exception);
        image_info=CloneImageInfo((ImageInfo *) NULL);

        sprintf(image_info->filename,"%s", filename);
        image=ReadImage(image_info,&exception);

        if (image == (Image *) NULL)
                return NULL ;

        w = image->columns ;
        h = image->rows ;

//printf("%d\n", w);
//printf("%d\n", h);

        // Tidy up
        DestroyImageInfo(image_info);
        DestroyExceptionInfo(&exception);

        return (void*)image ;
 }

void vetCodec_IMG::im_get_data(void *img, int *rgb)
{
    unsigned int cnt ;
    PixelPacket *pp ;
    int *optr ;
    PixelPacket *iptr ;
    unsigned int sz ;
    Image *image ;

    image = (Image*)img ;

    pp =  GetImagePixels( image, 0, 0, image->columns, image->rows) ;

    sz = image->columns*image->rows ;

    for(cnt=0,iptr=pp, optr=rgb ; cnt<sz ; cnt++, iptr++){
        *(optr++) = iptr->red >> 8 ;
        *(optr++) = iptr->green >> 8 ;// should be 16
        *(optr++) = iptr->blue >> 8 ;
    }
}
void vetCodec_IMG::im_get_data(void *img, unsigned char *rgb)
{
    unsigned int cnt ;
    PixelPacket *pp ;
    unsigned char *optr ;
    PixelPacket *iptr ;
    unsigned int sz ;
    Image *image ;

    image = (Image*)img ;

    pp =  GetImagePixels( image, 0, 0, image->columns, image->rows) ;

    sz = image->columns*image->rows ;

    for(cnt=0,iptr=pp, optr=rgb ; cnt<sz ; cnt++, iptr++){
        *(optr++) = (unsigned char)( iptr->red >> 8 );
        *(optr++) = (unsigned char)( iptr->green >> 8 );
        *(optr++) = (unsigned char)( iptr->blue >> 8 );
    }
}


void vetCodec_IMG::im_get_data_grey(void *img, int *d)
{
    unsigned int cnt ;
    PixelPacket *pp ;
    int *optr ;
    PixelPacket *iptr ;
    unsigned int sz ;
    Image *image ;

    image = (Image*)img ;

    pp =  GetImagePixels( image, 0, 0, image->columns, image->rows) ;

    sz = image->columns*image->rows ;

    for(cnt=0,iptr=pp, optr=d ; cnt<sz ; cnt++, iptr++, optr++){
        *optr = iptr->red >> 8 ;
        *optr += iptr->green >> 8 ;
        *optr += iptr->blue >> 8 ;
        *optr /= 3 ;
    }
}

void vetCodec_IMG::im_free(void *img)
{
    Image *image ;

    image = (Image*)img ;

    DestroyImage(image);

}




vetCodec_IMG::vetCodec_IMG(char *filename) : vetCodec()
 {
        DEBUGMSG("vetCodec_IMG::vetCodec_IMG(char *filename, FileFormat format) [CONTRUCTOR] ", *filename)

        myParams = NULL;
        reset();
        setParameters(NULL);

        load( filename );

        strcpy(myParams->fileNameBase, filename);
 }

vetCodec_IMG::vetCodec_IMG( vetCodec_IMGParameters* initParams ) : vetCodec()
 {
        DEBUGMSG("vetCodec_IMG::vetCodec_IMG(vetCodec_IMGParameters* initParams) [CONTRUCTOR] ", *filename)

        myParams = NULL;
        reset();
        setParameters(initParams);
 }

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

        setName("Bitmap Coder");
        setDescription("Read or write images to bitmap format.");
        setVersion(1.0);

        if (myParams != NULL)
         {
                myParams->reset();
                strcpy(fileNameBuffer, myParams->fileNameBase);
         }

        return VETRET_OK;
 }


VETRESULT vetCodec_IMG::setParameters (vetCodec_IMGParameters* initParams)
 {

        if ( initParams == NULL )
                myParams = new vetCodec_IMGParameters();
        else
                myParams = initParams;

        return VETRET_OK;
 }

bool vetCodec_IMG::EoF()        // buggy
 {
         return false;
 }


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

        return VETRET_NOT_IMPLEMENTED;

 }

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

        int ret = VETRET_OK;

        if ( myParams->autoOuput && !myParams->doBuffering )
         {
                doFileNameCurrent();


                ret = load(img, fileNameBuffer);

                if ( myParams->fileNameProgression )
                        myParams->fileNameIndex++;

                return ret;
         }

        if ( myParams->autoInput )
         {
                doFileNameCurrent();

                ret = load(fileNameBuffer);

                if ( myParams->fileNameProgression )
                        myParams->fileNameIndex++;
         }


//      vetFrameRGB::operator >> (img);

        return ret;
 }


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

        return VETRET_NOT_IMPLEMENTED;

 }



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

        return VETRET_NOT_IMPLEMENTED;

 }


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

        int ret = VETRET_OK;

        if ( myParams->autoOuput && !myParams->doBuffering )
         {
                doFileNameCurrent();

                ret = save(img, fileNameBuffer);

                if ( myParams->fileNameProgression )
                        myParams->fileNameIndex++;

                return ret;
         }

//      vetFrameRGB::operator << (img);

        if ( myParams->autoOuput )
         {
                doFileNameCurrent();

                ret = save(fileNameBuffer);

                if ( myParams->fileNameProgression )
                        myParams->fileNameIndex++;
         }

        return ret;
 }

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

        return VETRET_NOT_IMPLEMENTED;

 }

void vetCodec_IMG::setFileName(const char *filename)
 {
        strncpy(myParams->fileNameBase, filename, 64);
        strcpy(fileNameBuffer, myParams->fileNameBase);
 }


void vetCodec_IMG::doFileNameCurrent()
 {

        sprintf( fileNameIndexBuffer, "%d", myParams->fileNameIndex );

        strcpy( fileNameBuffer, myParams->fileNameBase );

        if ( myParams->fileNameIndex != -1 )
                strcat( fileNameBuffer, fileNameIndexBuffer );

        strcat( fileNameBuffer, (const char*)".bmp" );

        DEBUGMSG("void vetCodec_IMG::doFileNameCurrent()", fileNameBuffer);

 }


void vetCodec_IMG::getFileNameCurrent(char* filename)
 {
        doFileNameCurrent();
        strcpy( filename, fileNameBuffer );
 }



VETRESULT vetCodec_IMG::save()
 {
        INFO("VETRESULT vetCodec_IMG::save() [saving buffered data]")

        int ret = VETRET_OK;


        doFileNameCurrent();
//      ret = save(tmp, fileNameBuffer);
        return VETRET_NOT_IMPLEMENTED;

        return ret;
}

VETRESULT vetCodec_IMG::save(char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::save(char *filename, FileFormat format) [saving buffered data]", filename)

        return VETRET_NOT_IMPLEMENTED;

 }


VETRESULT vetCodec_IMG::load()
 {
        INFO("VETRESULT vetCodec_IMG::load() [loading data to buffer]")

        int ret = VETRET_OK;

        vetFrameYUV420 tmp;
        tmp.autoFreeData = false;// tmp used as a struct..

        doFileNameCurrent();
        ret = load(tmp, fileNameBuffer);



        return ret;
}


VETRESULT vetCodec_IMG::load(char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::load(char *filename, FileFormat format) [loading data to buffer]", filename)

        int ret = VETRET_OK;
        vetFrameYUV420 tmp;
        tmp.autoFreeData = false;// tmp used as a struct.. UMH=????????=??????????????????????

        ret = load(tmp, filename);


        return ret;
 }



//STATIC


VETRESULT vetCodec_IMG::load(vetFrameYUV420& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::load(vetFrameYUV420& source, char *filename, ..) [loading file data to frame]", filename)

        return VETRET_NOT_IMPLEMENTED;

 }

VETRESULT vetCodec_IMG::load(vetFrameRGB24& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::load(vetFrameRGB24& source, char *filename, ..) [loading file data to frame]", filename)

        int ret = VETRET_OK;
        void* img = NULL;
        bool ok;

        unsigned int w, h;

    if ( (img=im_load((char *)filename, w, h, NULL) ) == NULL )

        ok = false ;

    else
         {
                if ( w*h == 0 )

                        return VETRET_PARAM_ERR;

                else if (w*h != source.width*source.height)
                 {
                        if (source.data != NULL)
                                delete source.data;
                        source.data = new PixelRGB24[w*h];
                 }
                source.width = w;
                source.height = h;
            im_get_data(img, (unsigned char*)source.data[0]) ;
         }

        return ret;
 }



VETRESULT vetCodec_IMG::load(vetFrameT<unsigned char>& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::load(vetFrameT& source, char *filename, ..) [loading file data to frame]", filename)

        if ( source.getWidth() != 0 || source.getHeight() != 0 )
                return VETRET_PARAM_ERR;

        int ret = VETRET_OK;


        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetCodec_IMG::save(vetFrameYUV420& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::save(vetFrameYUV420& source, char *filename, FileFormat format) [saving frame to file]", filename)
/*
        if ( source.width == 0 || source.height == 0 || source.data == NULL )
                return VETRET_PARAM_ERR;

        int ret = VETRET_OK;


        ImageInfo *image_info;
        image_info=CloneImageInfo((ImageInfo *) NULL);

        ExceptionInfo exception;

        GetExceptionInfo(&exception);


        Image* myI = ConstituteImage(source.width,source.height, "RGB", IntegerPixel, source.data[0], &exception);

    pp =  GetImagePixels( &myI, 0, 0, source.width,source.height) ;

    sz = source.width,source.height ;

    for(cnt=0,iptr=pp, optr=source.data[0] ; cnt<sz ; cnt++, iptr++){
        iptr->red = *(optr++);
        iptr->green = *(optr++);
        iptr->blue = *(optr++);
    }

        sprintf(image_info->filename,"%s", filename);

        WriteImage(image_info, myI);

        DestroyImageInfo(image_info);
        DestroyExceptionInfo(&exception);
        return ret;
*/

        return VETRET_NOT_IMPLEMENTED;

}

VETRESULT vetCodec_IMG::save(vetFrameRGB24& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::save(vetFrameRGB24& source, char *filename, FileFormat format) [saving frame to file]", filename)

        if ( source.getWidth() == 0 || source.getHeight() == 0 )
                return VETRET_PARAM_ERR;

        int ret = VETRET_OK;

        ImageInfo *image_info;
        image_info=CloneImageInfo((ImageInfo *) NULL);

        ExceptionInfo exception;

        GetExceptionInfo(&exception);


        Image* myI = ConstituteImage(source.width,source.height, "RGB", CharPixel, source.data[0], &exception);
/*
    pp =  GetImagePixels( &myI, 0, 0, source.width,source.height) ;

    sz = source.width,source.height ;

    for(cnt=0,iptr=pp, optr=source.data[0] ; cnt<sz ; cnt++, iptr++){
        iptr->red = *(optr++);
        iptr->green = *(optr++);
        iptr->blue = *(optr++);
    }
*/
        sprintf(image_info->filename,"%s", filename);

        WriteImage(image_info, myI);

        DestroyImageInfo(image_info);
        DestroyExceptionInfo(&exception);

        return ret;
}


VETRESULT vetCodec_IMG::save(vetFrameT<unsigned char>& source, const char *filename)
 {
        DEBUGMSG("VETRESULT vetCodec_IMG::save(vetFrameT& source, char *filename, FileFormat format) [saving frame to file]", filename)

        return VETRET_NOT_IMPLEMENTED;

 }



void vetCodec_IMG::setFileNameProgression(bool value) { myParams->fileNameProgression = value; }

void vetCodec_IMG::setAutoOutputEnabled(bool value) { myParams->autoOuput = value; }

void vetCodec_IMG::setAutoInputEnabled(bool value) { myParams->autoInput = value; }

void vetCodec_IMG::setDoBuffering(bool value) { myParams->doBuffering = value; }


int vetCodec_IMG::getFileNameIndex() { return myParams->fileNameIndex; }
bool vetCodec_IMG::isFileNameProgressionEnabled() { return myParams->fileNameProgression; }

bool vetCodec_IMG::isAutoInputEnabled() { return myParams->autoInput; }

bool vetCodec_IMG::isAutoOutputEnabled() { return myParams->autoOuput; }

bool vetCodec_IMG::isBufferingEnabled() { return myParams->doBuffering; }

vetCodec_IMGParameters::vetCodec_IMGParameters()
 {
        reset();
 }

vetCodec_IMGParameters::vetCodec_IMGParameters(char* filename)
 {
        reset();
        setFileName(filename);
}

void vetCodec_IMGParameters::reset()
 {
        strcpy(fileNameBase, (const char*)"OUTPUT_1\0");
        setDoBuffering(true);
        setFileNameProgression(true);
        setFileNameIndex(-1);
        setAutoInputEnabled(false);
        setAutoOutputEnabled(true);
 }



void vetCodec_IMGParameters::setFileName(const char *filename)
 {
        strncpy(fileNameBase, filename, 64);
 }


void vetCodec_IMGParameters::getFileName(char *filename)
 {
        strcpy(filename, fileNameBase);
 }


int vetCodec_IMGParameters::saveToStreamXML(FILE *fp)
 {
        if ( fp == NULL )
                return VETRET_PARAM_ERR;

        if( fprintf(fp, "<vetCodec_IMGParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <filename value=\"%s\" />\n", fileNameBase) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <fileNameIndex value=\"%i\" />\n", fileNameIndex) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <doBuffering value=\"%u\" />\n", (int)doBuffering) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <autoOuput value=\"%u\" />\n", (int)autoOuput) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <autoInput value=\"%u\" />\n", (int)autoInput) == EOF)
                return VETRET_INTERNAL_ERR;

        if( fprintf(fp, "</vetCodec_IMGParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        return VETRET_OK;
 }


int vetCodec_IMGParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetCodec_IMGParameters>\n") == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <filename value=\"%s\" />\n", fileNameBase) == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <fileNameIndex value=\"%i\" />\n", &fileNameIndex) == EOF )
                throw "error in XML file, unable to import data.";

        int boolTmp = 1;
        if ( fscanf(fp, "  <doBuffering value=\"%u\" />\n", &boolTmp) == EOF )
                throw "error in XML file, unable to import data.";

        if (boolTmp == 0)
                doBuffering = false;
        else
                doBuffering = true;

        boolTmp = 0;
        if ( fscanf(fp, "  <autoOuput value=\"%u\" />\n", &boolTmp) == EOF )
                throw "error in XML file, unable to import data.";

        if (boolTmp == 0)
                autoOuput = false;
        else
                autoOuput = true;

        boolTmp = 0;
        if ( fscanf(fp, "  <autoInput value=\"%u\" />\n", &boolTmp) == EOF )
                throw "error in XML file, unable to import data.";

        if (boolTmp == 0)
                autoInput = false;
        else
                autoInput = true;

        return VETRET_OK;
 }

---