BitmapUpdate.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// BitmapUpdate.cpp: implementation of the BitmapUpdate class.
//
//////////////////////////////////////////////////////////////////////

#include "BitmapUpdate.h"
#include "Bitmap.h"


namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

BitmapUpdate::BitmapUpdate() : DataSample("BitmapUpdate") {
        init(0, 0);
}

BitmapUpdate::BitmapUpdate(int w, int h) : DataSample("BitmapUpdate") {
        init(w, h);
}

BitmapUpdate::BitmapUpdate(JString filename, bool compress) : DataSample("BitmapUpdate") {
        init(0, 0);
        if (compress) {
                if (!readFromFileRLE(filename)) {
                }
        }
        else {
                if (!readFromFile(filename)) {
                }
        }
}

BitmapUpdate::~BitmapUpdate() {
        reset();
}

bool BitmapUpdate::init(int w, int h) {
//      setWidth(w);
        width = w;
        height = h;
//      setHeight(h);
        return true;
}

bool BitmapUpdate::reset() {
//      setWidth(0);
//      setHeight(0);
        width = height = 0;
        setUpdateType("");
        delete(data);
        clearDataFields();
        return true;
}
/*
bool BitmapUpdate::setWidth(int width) {
        return this->params.put("Width", JString(width));
}

int BitmapUpdate::getWidth() {
        return this->params.get("Width").toInt();
}

bool BitmapUpdate::setHeight(int height) {
        return this->params.put("Height", JString(height));
}

int BitmapUpdate::getHeight() {
        return this->params.get("Height").toInt();
}
*/
bool BitmapUpdate::setUpdateType(JString updateType) {
        return this->params.put("Update", updateType);
}

JString BitmapUpdate::getUpdateType() {
        return this->params.get("Update");
}

Bitmap* BitmapUpdate::toBitmap() {
        return new Bitmap(this);
}

HTMLPage* BitmapUpdate::toHTMLBitmap() {
        Bitmap* bitmap = this->toBitmap();
        HTMLPage* page = NULL;
        if (bitmap != NULL) {
                page = new HTMLPage(bitmap);
                delete(bitmap);
        }
        return page;
}


bool BitmapUpdate::setFullUpdate(Bitmap* bitmap) {
        if ((bitmap == NULL) || (bitmap->data == NULL))
                return false;
        reset();
        setUpdateType("Full");
        init(bitmap->width, bitmap->height);
        return setDataCopy(bitmap->data, bitmap->size);
}

bool BitmapUpdate::readFromFile(JString filename) {

//      JTime t1;

        BITMAPFILEHEADER* bmfh; // ={0};
        BITMAPINFOHEADER* bmih; // ={0};
        long count = 0;

        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL)
                return false;

//      JTime t2;

        char* src = (char*) dat;
        bmfh = (BITMAPFILEHEADER*) src;
        src += sizeof(BITMAPFILEHEADER);
        bmih = (BITMAPINFOHEADER*) src;
        src += sizeof(BITMAPINFOHEADER);

        if (bmih->biCompression != 0) {
                delete [] dat;
                return false;
        }
        
        if (bmih->biBitCount != 24) {
                delete [] dat;
                return false;
        }

//      JTime t3;

        int depth = bmih->biBitCount;
        int planes = bmih->biPlanes;
        width = bmih->biWidth;
        height = bmih->biHeight;

        if(bmih->biSizeImage==0)
                bmih->biSizeImage=bmfh->bfSize-bmfh->bfOffBits;

        if (len < (int)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (width * height * ((int)(depth/8))) ) ) {
                delete [] dat;
                return false;
        }

//      JTime t4;

//      setWidth(width);
//      setHeight(height);

//      JTime t5;

        this->size = width * height * 4;
        data = new char[this->size];
        if (data == NULL) {
                this->size = 0;
                delete [] dat;
                return false;
        }

//      JTime t6;
        Bitmap::convertBitmapFileData(src, width, height, (int)(bmih->biBitCount/8), data, this->size);
//      JTime t7;

        delete [] dat;
        setUpdateType("Full");
//      JTime t8;
//              printf("                                               Time: %s\n", (char*) JString::format("%d  %d  %d  %d  %d  %d  %d  =  %d",
//                      t2.microDifference(t1), t3.microDifference(t2), t4.microDifference(t3), t5.microDifference(t4), t6.microDifference(t5), t7.microDifference(t6), t8.microDifference(t7), t8.microDifference(t1)));
        return true;
}

bool BitmapUpdate::readFromFileRLE(JString filename) {

        BITMAPFILEHEADER* bmfh; // ={0};
        BITMAPINFOHEADER* bmih; // ={0};
        long count = 0;

        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL)
                return false;

        char* src = (char*) dat;
        bmfh = (BITMAPFILEHEADER*) src;
        src += sizeof(BITMAPFILEHEADER);
        bmih = (BITMAPINFOHEADER*) src;
        src += sizeof(BITMAPINFOHEADER);

        if (bmih->biCompression != 0) {
                delete [] dat;
                return false;
        }
        
        if (bmih->biBitCount != 24) {
                delete [] dat;
                return false;
        }

        int depth = bmih->biBitCount;
        int planes = bmih->biPlanes;
        width = bmih->biWidth;
        height = bmih->biHeight;

        if(bmih->biSizeImage==0)
                bmih->biSizeImage=bmfh->bfSize-bmfh->bfOffBits;

        if (len < (int)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (width * height * ((int)(depth/8))) ) ) {
                delete [] dat;
                return false;
        }

//      setWidth(width);
//      setHeight(height);

/*      this->size = width * height * 4;
        data = new char[this->size];
        if (data == NULL) {
                this->size = 0;
                delete [] dat;
                return false;
        }*/

        data = Bitmap::convertBitmapFileDataRunLength(src, width, height, (int)(bmih->biBitCount/8), this->size);

        delete [] dat;
        if (data == NULL)
                return false;

        setUpdateType("RunLength");
        return true;
}

bool BitmapUpdate::readFromFileDiff(JString filename, Bitmap* oldBitmap) {
        BITMAPFILEHEADER* bmfh; // ={0};
        BITMAPINFOHEADER* bmih; // ={0};
        long count = 0;

        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL)
                return false;

        char* src = (char*) dat;
        bmfh = (BITMAPFILEHEADER*) src;
        src += sizeof(BITMAPFILEHEADER);
        bmih = (BITMAPINFOHEADER*) src;
        src += sizeof(BITMAPINFOHEADER);

        if (bmih->biCompression != 0) {
                delete [] dat;
                return false;
        }
        
        if (bmih->biBitCount != 24) {
                delete [] dat;
                return false;
        }

        int depth = bmih->biBitCount;
        int planes = bmih->biPlanes;
        width = bmih->biWidth;
        height = bmih->biHeight;

        if(bmih->biSizeImage==0)
                bmih->biSizeImage=bmfh->bfSize-bmfh->bfOffBits;

        if (len < (int)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (width * height * ((int)(depth/8))) ) ) {
                delete [] dat;
                return false;
        }

//      setWidth(width);
//      setHeight(height);

        data = Bitmap::differenceBitmapFileData(oldBitmap->data, src, width, height, (int)(bmih->biBitCount/8), this->size);

        delete [] dat;
        if (data == NULL)
                return false;

        setUpdateType("Dif");
        return true;
}

bool BitmapUpdate::readFromFileRLEDiff(JString filename, Bitmap* oldBitmap) {
        BITMAPFILEHEADER* bmfh; // ={0};
        BITMAPINFOHEADER* bmih; // ={0};
        long count = 0;

        int len;
        char* dat = JFile::readAFileBinary(filename, len);
        if (dat == NULL)
                return false;

        char* src = (char*) dat;
        bmfh = (BITMAPFILEHEADER*) src;
        src += sizeof(BITMAPFILEHEADER);
        bmih = (BITMAPINFOHEADER*) src;
        src += sizeof(BITMAPINFOHEADER);

        if (bmih->biCompression != 0) {
                delete [] dat;
                return false;
        }
        
        if (bmih->biBitCount != 24) {
                delete [] dat;
                return false;
        }

        int depth = bmih->biBitCount;
        int planes = bmih->biPlanes;
        width = bmih->biWidth;
        height = bmih->biHeight;

        if(bmih->biSizeImage==0)
                bmih->biSizeImage=bmfh->bfSize-bmfh->bfOffBits;

        if (len < (int)(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (width * height * ((int)(depth/8))) ) ) {
                delete [] dat;
                return false;
        }

//      setWidth(width);
//      setHeight(height);

        data = Bitmap::differenceBitmapFileDataRunLength(oldBitmap->data, src, width, height, (int)(bmih->biBitCount/8), this->size);

        delete [] dat;
        if (data == NULL)
                return false;

        setUpdateType("DifRunLength");
        return true;
}


bool BitmapUpdate::update(BitmapUpdate* update) {
        return false;
}
















} // namespace cmlabs

---