iTGA.h

Go to the documentation of this file.

/*
imagen - Simple object-oriented imaging library
Copyright (C) 2011-2012 Mark D. Procarione

imagen 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 3 of the License, or (at your option) any later version.

imagen 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 General Public License for more details.
*/

#ifndef __ITGA_H__
#define __ITGA_H__

#include "imagen.h"

#ifdef IMAGEN_TGA

#include "iAbstractImage.h"
#include "iLinkedList.h"

namespace imagen
{

    class iTGA : public iAbstractImage
    {
        private:
            #pragma pack(1)

            struct TGA_HEADER
            {
                TGA_HEADER();
                void clear();

                iBYTE IDLength;        // 00h  Size of Image ID field
                iBYTE ColorMapType;    // 01h  Color map type
                iBYTE ImageType;       // 02h  Image type code
                iWORD CMapStart;       // 03h  Color map origin
                iWORD CMapLength;      // 05h  Color map length
                iBYTE CMapDepth;       // 07h  Depth of color map entries
                iWORD XOffset;         // 08h  X origin of image
                iWORD YOffset;         // 0Ah  Y origin of image
                iWORD Width;           // 0Ch  Width of image
                iWORD Height;          // 0Eh  Height of image
                iBYTE PixelDepth;      // 10h  Image pixel size
                iBYTE ImageDescriptor; // 11h  Image descriptor byte
            }; // __attribute__((packed)); // This might hurt portability, as it's exclusive to GCC

            struct TGA_FOOTER
            {
                TGA_FOOTER();
                void clear();

                iDWORD ExtensionOffset;  // Extension Area Offset
                iDWORD DeveloperOffset;  // Developer Directory Offset
                iCHAR  Signature[16];    // TGA Signature
                iCHAR  ReservedChar;     // Reserved Character
                iCHAR  StringTerminator; // Binary Zero String Terminator
            };

            struct TGA_EXTENSION
            {
                TGA_EXTENSION();
                void clear();

                iWORD  Size;               // Extension Size
                iCHAR  AuthorName[41];     // Author Name
                iCHAR  AuthorComment[324]; // Author Comment
                iWORD  StampMonth;         // Date/Time Stamp: Month
                iWORD  StampDay;           // Date/Time Stamp: Day
                iWORD  StampYear;          // Date/Time Stamp: Year
                iWORD  StampHour;          // Date/Time Stamp: Hour
                iWORD  StampMinute;        // Date/Time Stamp: Minute
                iWORD  StampSecond;        // Date/Time Stamp: Second
                iCHAR  JobName[41];        // Job Name/ID
                iWORD  JobHour;            // Job Time: Hours
                iWORD  JobMinute;          // Job Time: Minutes
                iWORD  JobSecond;          // Job Time: Seconds
                iCHAR  SoftwareId[41];     // Software ID
                iWORD  VersionNumber;      // Software Version Number
                iBYTE  VersionLetter;      // Software Version Letter
                iDWORD KeyColor;           // Key Color
                iWORD  PixelNumerator;     // Pixel Aspect Ratio
                iWORD  PixelDenominator;   // Pixel Aspect Ratio
                iWORD  GammaNumerator;     // Gamma Value
                iWORD  GammaDenominator;   // Gamma Value
                iDWORD ColorOffset;        // Color Correction Offset
                iDWORD StampOffset;        // Postage Stamp Offset
                iDWORD ScanOffset;         // Scan-Line Table Offset
                iBYTE  AttributesType;     // Attributes Types
            };

            struct TGA_DEVTAG
            {
                iWORD  TagNumber;  // ID Number of the tag
                iDWORD DataOffset; // Offset location of the tag data
                iDWORD DataSize;   // Size of the tag data in bytes
            };
            #pragma pack()

        public:
            struct TargaDevField
            {
                TargaDevField() : data(NULL), size(0), tagID(0) {};


                TargaDevField( Iubyte *d, int sz, int id ) : data(d), size(sz), tagID(id) {};

                Iubyte *data;
                int tagID;
                int size;
            };

            enum TargaType
            {
                NoData = 0,
                ColMap = 1,
                TrueCol = 2,
                BW = 3,
                RLE_ColMap = 9,
                RLE_TrueCol = 10,
                RLE_BW = 11
            };

            enum TargaOrigin
            {
                OriginBL = 0,
                OriginBR = 1,
                OriginUL = 2,
                OriginUR = 3
            };

            enum TargaVersion
            {
                v1_0 = 1,
                v2_0 = 2
            };

        public:
            iTGA();


            iTGA( const iTGA &img );

            iTGA( const iAbstractImage &img );


            iTGA( int w, int h, iImageFormat f );


            iTGA( Iubyte *d, int w, int h, iImageFormat f, int b );


            iTGA( const char *filename );


            iTGA( Iubyte *buf, int len );


            iTGA( iDataStream *s );

            ~iTGA();

            void clear();

            bool isFormatSupported( iImageFormat fmt ) const;

            static bool isValid( iDataStream *s );

            void setImageID( const char id[255] );

            const char *getImageID() const { return imageID; }


            void setTargaVersion( TargaVersion ver ) { tgaVer = ver; }

            TargaVersion getTargaVersion() const { return tgaVer; }


            void addDevField( const TargaDevField &field ) { devField.append(field); }


            void setJobName( const char *name ) { jobName = name; }


            const char *getJobName() const { return jobName; }


            void enableRLE( bool brle ) { useRle = brle; }


            void enableExtension( bool bext ) { useExt = bext; }


            void enableDevArea( bool bdev ) { useDev = bdev; }

            iTGA &operator=( const iTGA &img );

            iTGA &operator=( const iAbstractImage &img );

        protected:
            void init();
            bool loadImage();
            bool saveImage();

        private:
            bool readHeader();
            bool readFooter();
            bool readDevArea();
            bool readExtension();
            bool readImageID();
            bool readColMapData();
            bool validateHeader();
            bool readImageData();
            bool readRaw();
            bool readRLE();

            bool writeHeader();
            bool writeFooter();
            bool writeDevArea();
            bool writeExtension();
            bool writeImageID();
            bool writeColMapData();
            bool writeImageData();
            bool writeRaw( Iubyte *buf );
            bool writeRLE( Iubyte *buf );

            int compressRLELine( Iubyte *in, Iuint n, Iubyte *out );
            int countDiffPixels( Iubyte *buf, Iuint count );
            int countSamePixels( Iubyte *buf, Iuint count );

            Iuint getDevAreaSize();
            Iuint getTargaSize();

            iImageOrigin TargaOrigin2iImageOrigin( TargaOrigin org );
            TargaOrigin iImageOrigin2TargaOrigin( iImageOrigin org );

        private:
            TGA_HEADER header;
            TGA_FOOTER footer;
            TGA_EXTENSION extension;
            char imageID[255];
            TargaVersion tgaVer;
            int alphabits;
            const char *jobName;

            iLinkedList<TargaDevField> devField;

            // Write members
            bool useRle;
            bool useExt;
            bool useDev;
    };
}

#endif // IMAGEN_TGA

#endif // __ITGA_H__