vetCodec_BMP.cpp

Go to the documentation of this file.

#include "vetCodec_BMP.h"

#include <new>          // bad_alloc exception

#include <string.h>     // memcpy
#include "external_BMP/MicrosoftBMP_RT.h"
#include "external_BMP/MicrosoftRCBMP_RT.h"
#include "external_BMP/MicrosoftMonoBMP_RT.h"

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



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

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

        load( filename, format );

        strcpy(myParams->fileNameBase, filename);
        myParams->fileFormat = format;
 }

vetCodec_BMP::vetCodec_BMP( vetCodec_BMPParameters* initParams ) : vetFrameRGB96(), vetCodec()
 {
        DEBUGMSG("vetCodec_BMP::vetCodec_BMP(vetCodec_BMPParameters* initParams) [CONTRUCTOR] ", *filename)

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

VETRESULT vetCodec_BMP::reset()
 {
        INFO("int vetCodec_BMP::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_BMP::setParameters (vetCodec_BMPParameters* initParams)
 {

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

        return VETRET_OK;
 }

bool vetCodec_BMP::EoF()        // buggy
 {
         if (data == NULL)
                return true;
         return false;
 }

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

        VETRESULT ret = VETRET_OK;

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


                ret = load(img, fileNameBuffer, myParams->fileFormat);

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

                return ret;
         }

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

                ret = load(fileNameBuffer, myParams->fileFormat);

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


        vetFrameRGB96::operator >> (img);

        return ret;
 }

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

        VETRESULT ret = VETRET_OK;

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


                ret = load(img, fileNameBuffer, myParams->fileFormat);

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

                return ret;
         }

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

                ret = load(fileNameBuffer, myParams->fileFormat);

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


        vetFrameRGB96::operator >> (img);

        return ret;
 }


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

        return VETRET_NOT_IMPLEMENTED;
 }



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

        VETRESULT ret = VETRET_OK;

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

                ret = save(img, fileNameBuffer, myParams->fileFormat);

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

                return ret;
         }

        vetFrameRGB96::operator << (img);

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

                ret = save(fileNameBuffer, myParams->fileFormat);

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

        return ret;
 }


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

        VETRESULT ret = VETRET_OK;

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

                ret = save(img, fileNameBuffer, myParams->fileFormat);

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

                return ret;
         }

        vetFrameRGB96::operator << (img);

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

                ret = save(fileNameBuffer, myParams->fileFormat);

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

        return ret;
 }

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

        return VETRET_NOT_IMPLEMENTED;

 }

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


void vetCodec_BMP::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_BMP::doFileNameCurrent()", fileNameBuffer);

 }


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



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

        VETRESULT ret = VETRET_OK;

        doFileNameCurrent();
        ret = save(reinterpret_cast<vetFrameRGB96&>(*this ), fileNameBuffer, myParams->fileFormat);

        return ret;
}

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

        VETRESULT ret = VETRET_OK;

        ret = save(reinterpret_cast<vetFrameRGB96&>(*this), filename, format);

        return ret;
 }


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

        VETRESULT ret = VETRET_OK;

        doFileNameCurrent();
        ret = load(reinterpret_cast<vetFrameRGB96&>(*this), fileNameBuffer, myParams->fileFormat);

        return ret;
}


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

        VETRESULT ret = VETRET_OK;

        ret = load(reinterpret_cast<vetFrameRGB96&>(*this), filename, format);

        return ret;
 }


//STATICs


VETRESULT vetCodec_BMP::load(vetFrameRGB96& source, const char *filename, FileFormat format)
 {
        DEBUGMSG("int vetCodec_BMP::load(vetFrameCache& source, char *filename, ..) [loading file data to frame]", filename)

        VETRESULT ret = VETRET_OK;

        switch (format)
         {
                case FORMAT_BMP_24:
                                {
                                MicrosoftBMP_RT bmp(filename);

                                if ( !bmp.read() )
                                        throw("Invalid Bitmap file specified");

                                source.reAllocCanvas(bmp.ImageWidth, bmp.ImageHeight);
                                bmp.extract_data( (int *)source.data );
                                }
                                break;

                case FORMAT_BMP_RC:
                                {
                                MicrosoftRCBMP_RT bmp(filename);

                                if ( !bmp.read() )
                                        throw("Invalid Bitmap file specified");

                                source.reAllocCanvas(bmp.ImageWidth, bmp.ImageHeight);
                                bmp.extract_data( (int *)source.data );
                                }
                                break;

                case FORMAT_BMP_MONO:
                                {
                                MicrosoftMonoBMP_RT bmp(filename);

                                if ( !bmp.read() )
                                        throw("Invalid Bitmap file specified");

                                source.reAllocCanvas(bmp.ImageWidth, bmp.ImageHeight);
                                bmp.extract_data( (int *)source.data );
                                }
                                break;

                default:        // FORMAT_BMP_ANY
                                {
                                // Check all formats
                                MicrosoftBMP_RT* bmp;
                                MicrosoftRCBMP_RT *bmp_rc;
                                MicrosoftMonoBMP_RT *bmp_mono;

                                if ( ( bmp = new  MicrosoftBMP_RT(filename) ) != NULL && bmp->read() )
                                 {
                                        // 24 bit bmp
                                        source.reAllocCanvas(bmp->ImageWidth, bmp->ImageHeight);
                                        bmp->extract_data( (int *)source.data );

                                 }
                                else if ( (bmp_rc = new  MicrosoftRCBMP_RT(filename) ) != NULL && bmp_rc->read() )
                                 {
                                         // Reduced clour (palette) bmp
                                        source.reAllocCanvas(bmp->ImageWidth, bmp->ImageHeight);
                                        bmp->extract_data( (int *)source.data );

                                }
                                else if ( (bmp_mono = new  MicrosoftMonoBMP_RT(filename) ) != NULL && bmp_mono->read() )
                                 {
                                        // Monochrome (b+w) bmp
                                        source.reAllocCanvas(bmp->ImageWidth, bmp->ImageHeight);
                                        bmp->extract_data( (int *)source.data ) ;

                                 }
                                }
                                break;

         }

        return ret;
 }

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

        VETRESULT ret = VETRET_OK;

        vetFrameRGB96 temp;
        ret = load(temp, filename, format);

        if ( ret == VETRET_OK )
                source << temp; // todo better !!

        return ret;
 }

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

        VETRESULT ret = VETRET_OK;

        return ret;
 }


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

        if ( source.width == 0 || source.height == 0 || source.data == NULL )
                return VETRET_PARAM_ERR;

        VETRESULT ret = VETRET_OK;

        switch (format)
         {
                case vetCodec_BMP::FORMAT_BMP_RC:
                                {
                                // Greyscale bitmap
                                MicrosoftRCBMP_RT *btmp;
                                btmp = new MicrosoftRCBMP_RT( filename );
                                if ( btmp == NULL )
                                        ret = VETRET_CODER_FILEOUT_ER;
                                else if ( !btmp->set_size(source.width, source.height) )
                                        ret = VETRET_CODER_SIZE_ER;
                                else if ( !btmp->set_palette_grey256() )
                                        ret = VETRET_CODER_PALETTE_ER;
                                else {
                                        btmp->put_data( (int *)source.data );
                                                                if ( !btmp->write() )
                                                        ret = VETRET_CODER_WRITE_ER;
                                 }
                                delete btmp ;
                                break;
                                }
                case vetCodec_BMP::FORMAT_BMP_MONO:
                                {
                                // Monochrome bitmap
                                MicrosoftMonoBMP_RT *btmp;
                                btmp = new MicrosoftMonoBMP_RT( filename );
                                if( btmp == NULL )
                                        ret = VETRET_CODER_FILEOUT_ER;
                                else if ( !btmp->set_size(source.width, source.height) )
                                        ret = VETRET_CODER_SIZE_ER;
                                else {
                                        btmp->put_data( (int *)source.data );
                                                                if ( !btmp->write() )
                                                        ret = VETRET_CODER_WRITE_ER;
                                 }
                                delete btmp ;
                                break;
                                }

                default:        // vetCodec_BMP::FORMAT_BMP_24 or vetCodec_BMP::FORMAT_BMP_ANY
                                {
                                // 24 Bit (full colour) bitmap (+default)
                                MicrosoftBMP_RT *btmp;
                                btmp = new MicrosoftBMP_RT( filename );

                                if ( btmp == NULL )
                                        ret = VETRET_CODER_FILEOUT_ER;
                                else if ( !btmp->set_size(source.width, source.height) )
                                        ret = VETRET_CODER_SIZE_ER;
                                else {
                                        btmp->put_data( (int *)source.data );
                                                                if ( !btmp->write() )
                                                        ret = VETRET_CODER_WRITE_ER;
                                 }
                                delete btmp ;
                                break;
                                }

         }

        return ret;
}

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

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

        VETRESULT ret = VETRET_OK;
        vetFrameRGB96 temp;

        source >> temp; // todobetter

        ret = save(temp, filename, format);

        return ret;
 }


//slow
VETRESULT vetCodec_BMP::save(vetFrameYUV420& source, const char *filename, FileFormat format)
 {
        DEBUGMSG("int vetCodec_BMP::save(vetFrameRGB96& source, char *filename, FileFormat format) [saving frame to file]", filename)

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

        VETRESULT ret = VETRET_OK;

        return ret;
 }



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

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

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

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

void vetCodec_BMP::setFileFormat(FileFormat format) { myParams->fileFormat = format; }

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

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

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

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

vetCodec_BMP::FileFormat vetCodec_BMP::getFileFormat()
 {
  return myParams->fileFormat;
 }








vetCodec_BMPParameters::vetCodec_BMPParameters()
 {
        reset();
 }

vetCodec_BMPParameters::vetCodec_BMPParameters(const char* filename, vetCodec_BMP::FileFormat format)
 {
        reset();
        setFileName(filename);
        setFileFormat(format);
}

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



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


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


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

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

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

        if ( fprintf(fp, "  <fileFormat value=\"%i\" />\n", (int)fileFormat) == 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_BMPParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        return VETRET_OK;
 }


int vetCodec_BMPParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetCodec_BMPParameters>\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;
 }

---