---

ctgaloader.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "ctgaloader.h"
#include <stdio.h>


int CTGALoader::m_GetHeader(char *filename) {
        FILE *file = fopen(filename, "rb");

        if (!file)
                return 1;


        if (fread(&m_sTgaHeader, 1, sizeof(m_sTgaHeader), file) != sizeof(m_sTgaHeader)) {
                fclose(file);
                return 1;
        }


        if (!m_sTgaHeader.cImageType)
                return 1;

        
        return 0;
}


int CTGALoader::m_GetFooter(char *filename) {
        FILE *file = fopen(filename, "rb");

        if (!file)
                return 1;

        fseek(file, -26L, SEEK_END);
        if (fread(&m_sTgaFooter, 1, sizeof(m_sTgaFooter.cFooter), file) != sizeof(m_sTgaFooter.cFooter)) {
                fclose(file);
                return 1;
        }

        //handle footer
        memcpy(&m_sTgaFooter.udExtensionAreaOffset, m_sTgaFooter.cFooter, 4);
        memcpy(&m_sTgaFooter.udDeveloperDirectoryOffset, m_sTgaFooter.cFooter + 4, 4);
        memcpy(&m_sTgaFooter.cSignature, m_sTgaFooter.cFooter + 8, 16);
        memcpy(&m_sTgaFooter.cAsciiChar, m_sTgaFooter.cFooter + 24, 1);
        memcpy(&m_sTgaFooter.cStringTerminator, m_sTgaFooter.cFooter + 25, 1);
        m_sTgaFooter.cSignature[16] = '\0';

        return 0;
}


int CTGALoader::m_ExtractImageData(char *filename, ImageData_t *psImage) {
        int dBytesPerPixel;
        
        FILE *file = fopen(filename, "rb");
        if (!file)
                return 1;

        fseek(file, HEADER_SIZE, SEEK_SET);

        psImage->dWidth = m_sTgaHeader.ucImageWidth;
        psImage->dHeight = m_sTgaHeader.ucImageHeight;
        psImage->dBpp = m_sTgaHeader.cPixelDepth;
        psImage->cColorInfo = (m_sTgaHeader.cImageType & 0x01);
        dBytesPerPixel = psImage->dBpp / 8;
        psImage->dSize = psImage->dHeight * psImage->dWidth * dBytesPerPixel;

        psImage->pcImageData = (unsigned char *)malloc(psImage->dSize);
        if (!psImage->pcImageData) {
                fclose(file);
                return 1;
        }


        /*
                2 -> uncompressed true color image
                3 -> uncompressed black and white image
        */
        if ((m_sTgaHeader.cImageType == 2) || (m_sTgaHeader.cImageType == 3)) {
                //if uncompressed, load the whole data in one step
                if (fread(psImage->pcImageData, 1, psImage->dSize, file) != psImage->dSize) {
                        if (psImage->pcImageData != NULL)
                                free(psImage->pcImageData);
                        fclose(file);
                        return 1;
                }
        }
        /*
                10 -> compressed true color image
                11 -> compressed black and white image
        */
        else if ((m_sTgaHeader.cImageType == 10) || (m_sTgaHeader.cImageType == 11)) {
                unsigned char ucTempByte[4];
                unsigned char ucPackedHead;
                unsigned char *pAt;

                pAt = psImage->pcImageData;
                for (unsigned int i = 0; i < psImage->dSize; ) {
                        ucPackedHead = (unsigned char) fgetc(file);
                        //run length encoded
                        if (ucPackedHead & 0x80) {
                                ucPackedHead &= 0x7f;
                                ucPackedHead++;
                                //load the data
                                fread(ucTempByte, dBytesPerPixel, 1, file);
                                //and copy it as told in the packed head
                                for (unsigned int j = 0; j < ucPackedHead; j++) {
                                        memcpy(pAt, ucTempByte, dBytesPerPixel);
                                        i += dBytesPerPixel;
                                        pAt += dBytesPerPixel;
                                }
                        }
                        //raw mode
                        else if (!(ucPackedHead & 0x80)) {
                                ucPackedHead &= 0x7f;
                                ucPackedHead++;
                                        //load the data, told in the packed head
                                        fread(pAt, dBytesPerPixel, ucPackedHead, file);
                                        i += dBytesPerPixel * ucPackedHead;
                                        pAt += dBytesPerPixel * ucPackedHead;
                        }
                }
        }


        //if true color image change red and blue, cause tga is stored in BGR!!!
        if (!psImage->cColorInfo) {
                unsigned char ucTemp; 
                for (unsigned int i = 0; i < psImage->dSize; i += dBytesPerPixel) {
                        ucTemp = psImage->pcImageData[i];
                        psImage->pcImageData[i] = psImage->pcImageData[i+2];
                        psImage->pcImageData[i+2] = ucTemp;
                }
        }

        fclose(file);

        return 0;
}


ImageData_t *CTGALoader::LoadTgaImage(char *filename) {

        ImageData_t *psImage = new ImageData_t;
        

        if (m_GetHeader(filename))
                return NULL;

        if (m_GetFooter(filename))
                return NULL;

        if (m_ExtractImageData(filename, psImage))
                return NULL;


        return psImage;
}


bool CTGALoader::SaveTgaImage(string path, ImageData_t *psImage) {

        FILE *file;
        char *buf = NULL;
        int buflen = 0;

        buflen = GetCurrentDirectory(0, buf);
        buf = new char[buflen];
        GetCurrentDirectory(buflen, buf);


        SetCurrentDirectory((path.substr(0, path.size() - 1)).c_str());
        int x = CreateDirectory("screenshots", NULL);
        if (x == 0) {
                if (GetLastError() != ERROR_ALREADY_EXISTS)
                        return false;
        }


        std::string name = path;
        name.append("screenshots\\");
        name.append("shot__.tga");


        for (int i = 0; i < 100; i++) {
                name[name.length() - 6] = (i / 10) + '0';
                name[name.length() - 5] = (i % 10) + '0';
                if ((file = fopen(name.c_str(), "rb")) == NULL)
                        break;
        }

        if (i == 100)
                return false;


        m_sTgaHeader.cIDLength = 0;
        m_sTgaHeader.cColorMapType = 0;
        m_sTgaHeader.cImageType = 2;
        //color map spec
        m_sTgaHeader.ucFirstEntryIndex = 0;
        m_sTgaHeader.ucColorMapLength = 0;
        m_sTgaHeader.cColorMapEntrySize = 0;
        //image spec
        m_sTgaHeader.ucXOrigin = 0;
        m_sTgaHeader.ucYOrigin = 0;
        m_sTgaHeader.ucImageWidth = psImage->dWidth;
        m_sTgaHeader.ucImageHeight = psImage->dHeight;
        m_sTgaHeader.cPixelDepth = psImage->dBpp * 8;
        m_sTgaHeader.cImageDescriptor = 0x0000;

        if ((file = fopen(name.c_str(), "wb")) == NULL)
                return false;


        unsigned char *image = new unsigned char[psImage->dSize];
        memcpy(image, psImage->pcImageData, psImage->dWidth * psImage->dHeight * 3);
        //if true color image change red and blue, cause tga is stored in BGR!!!
        if (!psImage->cColorInfo) {
                unsigned char ucTemp; 
                for (unsigned int i = 0; i < psImage->dSize; i += psImage->dBpp) {
                        ucTemp = image[i];
                        image[i] = image[i+2];
                        image[i+2] = ucTemp;
                }
        }
        
        
        fwrite(&m_sTgaHeader, sizeof(m_sTgaHeader), 1, file);
        fwrite(image, psImage->dSize, 1, file);
        fclose(file);

        if (image) {
                delete[] image;
                image = NULL;
        }

        if (buf) {
                SetCurrentDirectory(buf);
                delete[] buf;
                buf = NULL;
        }


        return true;
}

---