TgaTool.cpp

Go to the documentation of this file.

 
#include "TgaTool.h"
 
 
using namespace jbxl;
 
 
void  TGAImage::init(void) 
{ 
    xs      = 0;
    ys      = 0;
    col     = 0; 
    length  = 0;
    state   = 0;
    gp      = NULL;
 
    memset(hd, 0, TGA_HEADER_SIZE);
    memset(ft, 0, TGA_FOOTER_SIZE);
 
    int len = (int)strlen(TGA_FOOTER_STR) + 1;
    int pos = TGA_FOOTER_SIZE - len;
    memcpy(ft + pos, TGA_FOOTER_STR, len);
 
    return;
}
 
 
bool  TGAImage::isNull(void) 
{   
    if (gp==NULL) return true; 
    return false;
}
 
 
void  TGAImage::clear(void) 
{
    if (gp!=NULL) memset(gp, 0, xs*ys*col);
    return;
}
 
 
void  TGAImage::fill(uByte v) 
{
    if (gp!=NULL) memset(gp, v, xs*ys*col);
    return;
}
 
 
void  TGAImage::free(void) 
{  
    if (gp!=NULL) ::free(gp); 
    init();
 
    return;
}
 
 
void   TGAImage::setzero(int x, int y, int c) 
{ 
    getm(x, y, c); 
    if (gp==NULL) return;
 
    xs  = x;
    ys  = y;
    col = c;
    state = 0;
 
    memset(gp, 0, xs*ys*col);
 
    return;
}
 
 
void   TGAImage::getm(int x, int y, int c)
{
    gp = (uByte*)malloc(x*y*c);
    if (gp==NULL) {
        state = JBXL_GRAPH_MEMORY_ERROR;
        return;
    }
    memset(gp, 0, x*y*c);
    
    return;
}
 
 
 
 
TGAImage  jbxl::readTGAFile(const char* fname)
{
    TGAImage tga;
    FILE*  fp;
 
    fp = fopen(fname, "rb");
    if (fp==NULL) {
        tga.gp   = NULL;
        tga.state = JBXL_GRAPH_OPFILE_ERROR;
        return tga;
    }
 
    tga = readTGAData(fp);
    fclose(fp);
 
    return tga;
}
 
 
TGAImage  jbxl::readTGAData(FILE* fp)
{
    TGAImage tga;
    int rle = FALSE;
 
    fseek(fp, 0, 0);
    tga.free();
 
    size_t ret = fread(&tga.hd, TGA_HEADER_SIZE, 1, fp);
    if (ret<=0) {
        DEBUG_MODE PRINT_MESG("JBXL::readTGAData: ERROR: File read Error\n");
        tga.state = JBXL_FILE_READ_ERROR;
        return tga;
    }
 
    int kind = (int)tga.hd[2];
    if (kind == 2) {
        tga.col = 3;
    }
    else if (kind == 3) {
        tga.col = 1;
    }
    else if (kind == 10) {
        tga.col = 3;
        rle = TRUE;
    }
    else if (kind == 11) {
        tga.col = 1;
        rle = TRUE;
    }
    else {
        DEBUG_MODE PRINT_MESG("JBXL::readTGAData: ERROR: no supported File Format (%d)\n", kind);
        tga.state = JBXL_GRAPH_IVDFMT_ERROR;
        return tga;
    }    
 
    if (is_little_endian()) {
        tga.xs = tga.hd[12] + tga.hd[13]*256;
        tga.ys = tga.hd[14] + tga.hd[15]*256;
    }
    else {
        tga.xs = tga.hd[12]*256 + tga.hd[13];
        tga.ys = tga.hd[14]*256 + tga.hd[15];
    }
 
    uByte alpha = tga.hd[17] & 0x0f;        // αチャンネル
    if (alpha != 0x08 && alpha != 0x00) {
        DEBUG_MODE PRINT_MESG("JBXL::readTGAData: ERROR: unkonwn Alpha Channel (0x%02x)\n", alpha);
        tga.state = JBXL_GRAPH_IVDFMT_ERROR;
        return tga;
    }
    else if (alpha == 0x08) {
        tga.col++;
    }
    if (tga.col*8 != (int)tga.hd[16]) {
        tga.col = (int)tga.hd[16]/8;
        PRINT_MESG("JBXL::readTGAData: Warning: Not Match Color Num! set color num = %d\n", tga.col);
    }
    PRINT_MESG("JBXL::readTGAData: TGA File (%d, %d, %d)\n", tga.xs, tga.ys, tga.col);
 
    int datasize = tga.xs*tga.ys*tga.col;
    tga.length = datasize;
 
    tga.gp = (uByte*)malloc(datasize);
    if (tga.gp==NULL) {
        PRINT_MESG("JBXL::readTGAData: ERROR: out of Memory!\n");
        tga.state = JBXL_GRAPH_MEMORY_ERROR;
        return tga;
    }
    memset(tga.gp, 0, datasize);
 
    fseek(fp, (int)tga.hd[0], SEEK_CUR);
    if (rle) {
        // RLE
        int   size = 0;
        uByte chunk;
        uByte buf[LBUF];
 
        while (size<datasize && !feof(fp)) {
            ret = fread(&chunk, 1, 1, fp);
            if (ret<=0) {
                DEBUG_MODE PRINT_MESG("JBXL::readTGAData: ERROR: File read Error\n");
                tga.state = JBXL_FILE_READ_ERROR;
                return tga;
            }
            int rep = (int)(chunk & 0x7f) + 1;
            if (chunk & 0x80) {
                ret = fread(buf, tga.col, 1, fp);
                if (ret<=0) {
                    tga.state = JBXL_FILE_READ_ERROR;
                    return tga;
                }
                for (int j=0; j<rep; j++) {
                    for (int i=0; i<tga.col; i++) tga.gp[size++] = buf[i];
                }
            }
            else {
                if (tga.col*rep<LBUF) {
                    ret = fread(buf, tga.col*rep, 1, fp);
                    if (ret<=0) {
                        tga.state = JBXL_FILE_READ_ERROR;
                        return tga;
                    }
                    for (int i=0; i<tga.col*rep; i++) tga.gp[size++] = buf[i];
                }
                else {
                    for (int j=0; j<rep; j++) {
                        ret = fread(buf, tga.col, 1, fp);
                        if (ret<=0) {
                            tga.state = JBXL_FILE_READ_ERROR;
                            return tga;
                        }
                        for (int i=0; i<tga.col; i++) tga.gp[size++] = buf[i];
                    }
                }
            }
        }
        if (size!=datasize) {
            DEBUG_MODE PRINT_MESG("JBXL::readTGAData: ERROR: unpack RLE failed. (%d != %d), format = %d\n", size, datasize, kind);
            tga.state = JBXL_GRAPH_FILESZ_ERROR;
            return tga;
        }
        tga.hd[2] &= ~0x08; //  非圧縮状態
    }
    else {
        ret = fread(tga.gp, datasize, 1, fp);
        if (ret<=0) {
            tga.state = JBXL_FILE_READ_ERROR;
            return tga;
        }
    }
    if (!feof(fp)) {
        ret = fread(tga.ft, TGA_FOOTER_SIZE, 1, fp);
        if (ret<=0) {
            tga.state = JBXL_FILE_READ_ERROR;
            return tga;
        }
    }
    tga.state = 0;
    return tga;
}
 
 
int  jbxl::writeTGAFile(const char* fname, TGAImage* tga)
{
    FILE*  fp;
    int    ret;
 
    if (fname==NULL) return JBXL_GRAPH_IVDARG_ERROR;
    if (tga->col<=0 || tga->col>4) return JBXL_GRAPH_IVDCOLOR_ERROR;
    if (tga->gp==NULL) return JBXL_GRAPH_NODATA_ERROR;
 
    fp = fopen(fname, "wb");
    if (fp==NULL) {
        return JBXL_GRAPH_OPFILE_ERROR;
    }
 
    ret = writeTGAData(fp, tga);
    fclose(fp); 
 
    return ret;
}
 
 
int  jbxl::writeTGAData(FILE* fp, TGAImage* tga)
{
    if (fp==NULL) return JBXL_GRAPH_OPFILE_ERROR;
    if (tga->col<=0 || tga->col>4) return JBXL_GRAPH_IVDCOLOR_ERROR;
    if (tga->gp==NULL) return JBXL_GRAPH_NODATA_ERROR;
 
    fwrite(tga->hd, TGA_HEADER_SIZE, 1, fp);
    fwrite(tga->gp, tga->length, 1, fp);
    fwrite(tga->ft, TGA_FOOTER_SIZE, 1, fp);
 
    return 0;
}
 
 
int  jbxl::setupTGAData(TGAImage* tga, bool rle)
{
    if (tga->col<=0 || tga->col>4) return JBXL_GRAPH_IVDCOLOR_ERROR;
 
    memset(tga->hd, 0, TGA_HEADER_SIZE);
    if      (tga->col==3 || tga->col==4) tga->hd[2] = 2;    // Full Color
    else if (tga->col==1 || tga->col==2) tga->hd[2] = 3;    // Gray Scale
    else return JBXL_GRAPH_IVDFMT_ERROR;
 
    if (is_little_endian()) {
        tga->hd[12] = (uByte)(tga->xs%256);
        tga->hd[13] = (uByte)(tga->xs/256);
        tga->hd[14] = (uByte)(tga->ys%256);
        tga->hd[15] = (uByte)(tga->ys/256);
    }
    else {
        tga->hd[12] = (uByte)(tga->xs/256);
        tga->hd[13] = (uByte)(tga->xs%256);
        tga->hd[14] = (uByte)(tga->ys/256);
        tga->hd[15] = (uByte)(tga->ys%256);
    }
 
    tga->hd[16] = tga->col*8;                   // depth
    tga->hd[17] = 0x20;                         // 0x20: Y方向:Top->Down
    tga->hd[10] = tga->hd[14];                  // Y posion for 0x20
    tga->hd[11] = tga->hd[15];                  // 
    if (tga->col==2 || tga->col==4) {
        tga->hd[17] |= 0x08;                    // 0x08: αチャンネル深度
    }
    tga->length = tga->xs*tga->ys*tga->col;     // データ（gp）長
 
    if (rle && tga->gp!=NULL) {
        int len = tga->xs*tga->ys;
        uByte* index = (uByte*)malloc(len);
        if (index==NULL) return JBXL_GRAPH_MEMORY_ERROR;
        memset(index, 0, len);
 
        int idx = 0;
        int p = 0;
        while (p<len-1) {
            if (!memcmp(tga->gp + p*tga->col, tga->gp + (p+1)*tga->col, tga->col)) {
                index[idx]++;
                if (index[idx]==127) {
                    idx = p + 2;
                    p++;
                }
            }
            else {
                idx = p + 1;
            }
            p++;
        }
 
        // 変換後のサイズを計算
        int n = 0;
        p = 0;
        while (p < len-1) {
            n += tga->col + 1;
            if (index[p]!=0x00) p += index[p];
            p++;
        }
 
        if ((float)n < len*tga->col*0.8f) {
            DEBUG_MODE PRINT_MESG("JBXL::writeTGAData: exec RLE (%d -> %d)\n", len*tga->col, n);
            uByte* buf = (uByte*)malloc(len*tga->col);
            if (buf==NULL) {
                ::free(index);
                return JBXL_GRAPH_MEMORY_ERROR;
            }
            memset(buf, 0, len*tga->col);
            //
            int i = 0;
            int j = 0;
            while (i < len-1) {
                if (index[i]!=0x00) {
                    buf[j++] = 0x80 + index[i];
                    memcpy(buf+j, tga->gp + i*tga->col, tga->col);
                    j += tga->col;
                    i += index[i];
                }
                else {
                    buf[j++] = 0x00;
                    memcpy(buf+j, tga->gp + i*tga->col, tga->col);
                    j += tga->col;
                }
                i++;
            }
            //
            if (j==n) {
                tga->hd[2] |= 0x08;
                tga->length = n;
                ::free(tga->gp);
                tga->gp = buf;
            }
            else {
                DEBUG_MODE PRINT_MESG("JBXL::writeTGAData: Warning: missmatch RLE size (%d != %d)\n", j, n);
                DEBUG_MODE PRINT_MESG("JBXL::writeTGAData: Warning: stop RLE!\n");
                ::free(buf);
            }
            ::free(index);
        }
    }
    return 0;
}