Initial import. Contains the im, cd and iup librairies, and a "working" Makefile for them under linux.

1 files changed, 1113 insertions, 0 deletions

diff --git a/im/src/im_format_tga.cpp b/im/src/im_format_tga.cpp
new file mode 100755
index 0000000..86e968a
--- /dev/null
+++ b/im/src/im_format_tga.cpp
@@ -0,0 +1,1113 @@
+/** \file
+ * \brief TGA - Truevision Graphics Adapter File
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: im_format_tga.cpp,v 1.2 2008/12/03 15:45:34 scuri Exp $
+ */
+
+#include "im_format.h"
+#include "im_util.h"
+#include "im_format_all.h"
+#include "im_counter.h"
+#include "im_math.h"
+
+#include "im_binfile.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <memory.h>
+#include <time.h>
+#include <math.h>
+
+
+/*
+|--------|--------|------------------------------------------------------------|
+|    0   |     1  |  Number of Characters in Identification Field.             |
+|        |        |  This field is a one-byte unsigned integer, specifying     |
+|        |        |  the length of the Image Identification Field.  Its range  |
+|        |        |  is 0 to 255.  A value of 0 means that no Image            |
+|        |        |  Identification Field is included.                         |
+|--------|--------|------------------------------------------------------------|
+|    1   |     1  |  Color Map Type.                                           |
+|--------|--------|------------------------------------------------------------|
+|    2   |     1  |  Image Type Code.                                          |
+|--------|--------|------------------------------------------------------------|
+|    3   |     5  |  Color Map Specification.                                  |
+|    3   |     2  |  Color Map Origin.                                         |
+|        |        |  Integer ( lo-hi ) index of first color map entry.         |
+|    5   |     2  |  Color Map Length.                                         |
+|        |        |  Integer ( lo-hi ) count of color map entries.             |
+|    7   |     1  |  Color Map Entry Size.                                     |
+|        |        |  Number of bits in each color map entry.  16 for           |
+|        |        |  the Targa 16, 24 for the Targa 24, 32 for the Targa 32.   |
+|--------|--------|------------------------------------------------------------|
+|    8   |    10  |  Image Specification.                                      |
+|    8   |     2  |  X Origin of Image.                                        |
+|        |        |  Integer ( lo-hi ) X coordinate of the lower left corner   |
+|        |        |  of the image.                                             |
+|   10   |     2  |  Y Origin of Image.                                        |
+|        |        |  Integer ( lo-hi ) Y coordinate of the lower left corner   |
+|        |        |  of the image.                                             |
+|   12   |     2  |  Width of Image.                                           |
+|        |        |  Integer ( lo-hi ) width of the image in pixels.           |
+|   14   |     2  |  Height of Image.                                          |
+|        |        |  Integer ( lo-hi ) height of the image in pixels.          |
+|   16   |     1  |  Image Pixel Size.                                         |
+|        |        |  Number of bits in a stored pixel index.                   |
+|   17   |     1  |  Image Descriptor Byte.                                    |
+|        |        |  Bits 3-0 - number of attribute bits associated with each  |
+|        |        |             pixel.                                         |
+|        |        |  Bit 4    - reserved.  Must be set to 0.                   |
+|        |        |  Bit 5    - screen origin bit.                             |
+|        |        |             0 = Origin in lower left-hand corner.          |
+|        |        |             1 = Origin in upper left-hand corner.          |
+|        |        |             Must be 0 for Truevision images.               |
+|        |        |  Bits 7-6 - Data storage interleaving flag.                |
+|        |        |             00 = non-interleaved.                          |
+|        |        |             01 = two-way (even/odd) interleaving.          |
+|        |        |             10 = four way interleaving.                    |
+|        |        |             11 = reserved.                                 |
+|        |        |  This entire byte should be set to 0.  Don't ask me.       |
+|--------|--------|------------------------------------------------------------|
+|   18   | varies |  Image Identification Field.                               |
+|        |        |  Contains a free-form identification field of the length   |
+|        |        |  specified in byte 1 of the image record.  It's usually    |
+|        |        |  omitted ( length in byte 1 = 0 ), but can be up to 255    |
+|        |        |  characters.  If more identification information is        |
+|        |        |  required, it can be stored after the image data.          |
+|--------|--------|------------------------------------------------------------|
+
+Extension Area:
+
+* The inclusion of a scaled-down “postage stamp” copy of the image
+* Date and Time of image file creation
+* Author Name
+* Author Comments
+* Job Name
+* Job Accumulated Time
+* Gamma Value
+* Correct Color LUT
+* Pixel Aspect Ratio
+* Scan Line Offset Table
+* Key Color
+* Software Package Name and Version Number
+* Developer Definable Areas
+* Attribute (Alpha) channel Type
+* The ability for simple expansion
+*/
+
+static int iTGADecodeScanLine(imBinFile* handle, imbyte *DecodedBuffer, int width, int pixel_size)
+{
+  int i=0;
+  unsigned char runcount; /* repetition count field */
+  imbyte pixel_buffer[4];
+  
+  while (i < width) 
+  { 
+    imBinFileRead(handle, &runcount, 1, 1);  
+
+    if (runcount & 0x80)
+    { 
+      imBinFileRead(handle, pixel_buffer, pixel_size, 1); 
+      runcount &= 0x7F;
+
+      if (imBinFileError(handle))
+        return IM_ERR_ACCESS;     
+
+      runcount++;      
+      while (runcount-- && i < width)
+      {
+        memcpy(DecodedBuffer, pixel_buffer, pixel_size);
+        i++;
+        DecodedBuffer += pixel_size;
+      }
+    } 
+    else
+    { 
+      runcount++;
+      while (runcount-- && i < width)
+      {
+        imBinFileRead(handle, pixel_buffer, pixel_size, 1);
+        memcpy(DecodedBuffer, pixel_buffer, pixel_size);
+        i++;
+        DecodedBuffer += pixel_size;
+      }
+
+      if (imBinFileError(handle))
+        return IM_ERR_ACCESS;     
+    }
+  }
+
+  return IM_ERR_NONE;
+}
+
+static inline int iTGAEqualPixel(const imbyte* Buffer1, const imbyte* Buffer2, int pixel_size)
+{
+  while(pixel_size--)
+  {
+    if (*Buffer1++ != *Buffer2++)
+      return 0;
+  }
+  return 1;
+}
+
+static int iTGAEncodeScanLine(imbyte* EncodedBuffer, const imbyte* DecodedBuffer, int width, int pixel_size)
+{
+  imbyte pixel_buffer[4];
+  unsigned char runcount; /* Length of encoded pixel run          */
+  int x = 0;              /* Index into uncompressed data buffer  */
+  imbyte* StartBuffer = EncodedBuffer;
+
+  while (x < width)
+  {
+    runcount = 1;
+    memcpy(pixel_buffer, &DecodedBuffer[x*pixel_size], pixel_size);
+
+    // count equal pixels
+    while (x+runcount < width && runcount < 128 && 
+           iTGAEqualPixel(pixel_buffer, &DecodedBuffer[(x+runcount)*pixel_size], pixel_size))
+      runcount++; 
+
+    if (runcount == 1)
+    {
+      // count different pixels
+      while (x+runcount+1 < width && runcount < 128)
+      {
+        memcpy(pixel_buffer, &DecodedBuffer[(x+runcount)*pixel_size], pixel_size);
+
+        if (!iTGAEqualPixel(pixel_buffer, &DecodedBuffer[(x+runcount+1)*pixel_size], pixel_size))
+          runcount++; 
+        else
+          break;
+      }
+
+      *EncodedBuffer++ = (imbyte)(runcount-1);
+
+      memcpy(EncodedBuffer, &DecodedBuffer[x*pixel_size], runcount*pixel_size);
+      EncodedBuffer += runcount*pixel_size;
+    }
+    else
+    {
+      *EncodedBuffer++ = (imbyte)(0x80 | (runcount-1));
+
+      memcpy(EncodedBuffer, pixel_buffer, pixel_size);
+      EncodedBuffer += pixel_size;
+    }
+
+    x += runcount;
+  }
+
+  return EncodedBuffer-StartBuffer;      /* Return the number of unsigned chars written to buffer */
+}
+
+static const char* iTGACompTable[2] = 
+{
+  "NONE",
+  "RLE"
+};
+
+class imFileFormatTGA: public imFileFormatBase
+{
+  imBinFile* handle;          /* the binary file handle */
+  unsigned char id_lenght;
+  unsigned char map_type, image_type, map_bpp, bpp;
+
+  int ReadPalette();
+  int WritePalette();
+  void FixRGB();
+  int LoadExtensionArea();
+  int SaveExtensionArea();
+
+public:
+  imFileFormatTGA(const imFormat* _iformat): imFileFormatBase(_iformat) {}
+  ~imFileFormatTGA() {}
+
+  int Open(const char* file_name);
+  int New(const char* file_name);
+  void Close();
+  void* Handle(int index);
+  int ReadImageInfo(int index);
+  int ReadImageData(void* data);
+  int WriteImageInfo();
+  int WriteImageData(void* data);
+};
+
+class imFormatTGA: public imFormat
+{
+public:
+  imFormatTGA()
+    :imFormat("TGA", 
+              "Truevision Graphics Adapter File", 
+              "*.tga;*.icb;*.vst;*.tpic;", 
+              iTGACompTable, 
+              2, 
+              0)
+    {}
+  ~imFormatTGA() {}
+
+  imFileFormatBase* Create(void) const { return new imFileFormatTGA(this); }
+  int CanWrite(const char* compression, int color_mode, int data_type) const;
+};
+
+void imFormatRegisterTGA(void)
+{
+  imFormatRegister(new imFormatTGA());
+}
+
+int imFileFormatTGA::Open(const char* file_name)
+{
+  /* opens the binary file for reading with intel byte order */
+  handle = imBinFileOpen(file_name);
+  if (!handle)
+    return IM_ERR_OPEN;
+
+  imBinFileByteOrder(handle, IM_LITTLEENDIAN); 
+  
+  imBinFileRead(handle, &this->id_lenght, 1, 1);
+  imBinFileRead(handle, &this->map_type, 1, 1);
+  imBinFileRead(handle, &this->image_type, 1, 1);
+
+  if (imBinFileError(handle))
+  {
+    imBinFileClose(handle);
+    return IM_ERR_ACCESS;
+  }
+  
+  if (this->image_type != 1 && this->image_type != 2 && this->image_type != 3 && 
+      this->image_type != 9 && this->image_type != 10 && this->image_type != 11)
+  {
+    imBinFileClose(handle);
+    return IM_ERR_FORMAT;
+  }
+  
+  if (this->map_type != 0 && this->map_type != 1)
+  {
+    imBinFileClose(handle);
+    return IM_ERR_FORMAT;
+  }
+  
+  if (this->map_type == 0 && (this->image_type == 1 || this->image_type == 9))
+  {
+    imBinFileClose(handle);
+    return IM_ERR_FORMAT;
+  }
+  
+  if (this->image_type == 9 || this->image_type == 10 || this->image_type == 11)
+    strcpy(this->compression, "RLE");
+  else
+    strcpy(this->compression, "NONE");
+
+  this->image_count = 1;
+
+  return IM_ERR_NONE;
+}
+
+int imFileFormatTGA::New(const char* file_name)
+{
+  /* opens the binary file for writing with intel byte order */
+  handle = imBinFileNew(file_name);
+  if (!handle)
+    return IM_ERR_OPEN;
+
+  imBinFileByteOrder(handle, IM_LITTLEENDIAN); 
+
+  return IM_ERR_NONE;
+}
+
+void imFileFormatTGA::Close()
+{
+  imBinFileClose(handle);
+}
+
+void* imFileFormatTGA::Handle(int index)
+{
+  if (index == 0)
+    return (void*)this->handle;
+  else
+    return NULL;
+}
+
+int imFileFormatTGA::ReadImageInfo(int index)
+{
+  (void)index;
+  unsigned char byte_value;
+  unsigned short word_value;
+
+  this->file_data_type = IM_BYTE;
+  
+  if (this->image_type == 1 || this->image_type == 9)
+    this->file_color_mode = IM_MAP;
+  else if (this->image_type == 2 || this->image_type == 10)
+  {
+    this->file_color_mode = IM_RGB;
+    this->file_color_mode |= IM_PACKED;
+  }
+  else if (this->image_type == 3 || this->image_type == 11)
+    this->file_color_mode = IM_GRAY;
+  else
+    return IM_ERR_DATA;
+
+  if (this->map_type == 0)
+    imBinFileSeekOffset(handle, 5);  // jump color map information
+  else
+  {
+    /* jump 2 bytes (first entry index) */
+    imBinFileSeekOffset(handle, 2);
+    
+    imBinFileRead(handle, &word_value, 1, 2);
+    this->palette_count = word_value;
+    
+    imBinFileRead(handle, &this->map_bpp, 1, 1);
+
+    if (this->map_bpp == 15) this->map_bpp = 16;
+
+	  if (this->map_bpp != 16 && this->map_bpp != 24 && this->map_bpp != 32)
+      return IM_ERR_DATA;
+  }
+  
+  /* jump 4 bytes (X-Origin, Y-Origin) */
+  unsigned short xmin, ymin;
+  imBinFileRead(handle, &xmin, 1, 2);
+  imBinFileRead(handle, &ymin, 1, 2);
+
+  if (imBinFileError(handle))
+    return IM_ERR_ACCESS;
+
+  imAttribTable* attrib_table = AttribTable();
+
+  if (xmin && ymin)
+  {
+    attrib_table->Set("XScreen", IM_USHORT, 1, &xmin);
+    attrib_table->Set("YScreen", IM_USHORT, 1, &ymin);
+  }
+  
+  /* reads the image width */
+  imBinFileRead(handle, &word_value, 1, 2);
+  this->width = word_value;
+  
+  /* reads the image height */
+  imBinFileRead(handle, &word_value, 1, 2);
+  this->height = word_value;
+
+  if (imBinFileError(handle))
+    return IM_ERR_ACCESS;
+  
+  imBinFileRead(handle, &this->bpp, 1, 1);
+  
+  if (this->bpp > 8 && imColorModeSpace(this->file_color_mode) != IM_RGB)
+    return IM_ERR_DATA;
+  
+  if (this->bpp == 15) this->bpp = 16;
+
+	if (this->bpp != 8 && this->bpp != 16 && 
+      this->bpp != 24 && this->bpp != 32)
+    return IM_ERR_DATA;
+
+  if (this->bpp == 32)
+    this->file_color_mode |= IM_ALPHA;
+
+  // image descriptor
+  imBinFileRead(handle, &byte_value, 1, 1);
+  
+  if (byte_value & 0x20)
+    this->file_color_mode |= IM_TOPDOWN;
+  
+  // image ID
+  if (this->id_lenght)
+  {
+    char desc[256];
+    imBinFileRead(handle, desc, this->id_lenght, 1);
+    desc[this->id_lenght] = 0;
+    attrib_table->Set("Title", IM_BYTE, this->id_lenght+1, desc);
+  }
+  
+  if (imBinFileError(handle))
+    return IM_ERR_ACCESS;
+  
+  if (this->map_type)
+  {
+    if (!ReadPalette())
+      return IM_ERR_ACCESS;
+  }
+
+  long cur_offset = imBinFileTell(handle);
+  imBinFileSeekFrom(handle, -18);  
+  char ext_sig[18];
+  imBinFileRead(handle, ext_sig, 18, 1);
+  if (ext_sig[17] == 0 && imStrEqual(ext_sig, "TRUEVISION-XFILE."))
+  {
+    if (!LoadExtensionArea())
+      return IM_ERR_ACCESS;
+  }
+  imBinFileSeekTo(handle, cur_offset);  
+  
+  return IM_ERR_NONE;
+}
+
+int imFileFormatTGA::WriteImageInfo()
+{
+  unsigned char byte_value;
+  unsigned short word_value;
+
+  this->map_bpp = 0;
+  this->map_type = 0;
+
+  this->file_color_mode = imColorModeSpace(this->user_color_mode);
+  switch (this->file_color_mode)
+  {
+  case IM_BINARY:
+    this->convert_bpp = -1; // expand 1 to 255
+  case IM_GRAY:
+    this->bpp = 8;
+    if (imStrEqual(this->compression, "RLE"))
+      this->image_type = 11;
+    else
+      this->image_type = 3;
+    break;
+  case IM_MAP:
+    this->bpp = 8;
+    this->map_bpp = 24;
+    this->map_type = 1;
+    if (imStrEqual(this->compression, "RLE"))
+      this->image_type = 9;
+    else
+      this->image_type = 1;
+    break;
+  case IM_RGB:
+    this->bpp = 24;
+    this->file_color_mode |= IM_PACKED;
+    if (imStrEqual(this->compression, "RLE"))
+      this->image_type = 10;
+    else
+      this->image_type = 2;
+    break;
+  }
+
+  if (this->image_type > 3)
+  {
+    // allocates more than enough since compression algoritm can be ineficient
+    this->line_buffer_extra += 2*this->width*imColorModeDepth(this->file_color_mode);
+  }
+  
+  imAttribTable* attrib_table = AttribTable();
+
+  /* writes the TGA file header */
+
+  int length = 0;
+  const char* desc_attrib = (const char*)attrib_table->Get("Title", NULL, &length);
+  if (desc_attrib)
+  {
+    if (length > 255)
+      this->id_lenght = 255;
+    else
+      this->id_lenght = (imbyte)length;
+  }
+  else
+    this->id_lenght = 0;
+  
+  /* IDLength */
+  imBinFileWrite(handle, &this->id_lenght, 1, 1); 
+  
+  /* Color Map Type */
+  imBinFileWrite(handle, &this->map_type, 1, 1);
+  
+  /* Image Type */
+  imBinFileWrite(handle, &this->image_type, 1, 1);
+  
+  /* Color Map Specification - 1st entry index */
+  word_value = 0;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Color map length */
+  word_value = (unsigned short) this->palette_count;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Color Map Entry size */
+  byte_value = this->map_type? this->map_bpp: (imbyte)0;
+  imBinFileWrite(handle, &byte_value, 1, 1); 
+
+  if (imBinFileError(handle))
+    return IM_ERR_ACCESS;
+  
+  unsigned short xmin = 0, ymin = 0;
+  const void* attrib_data = attrib_table->Get("XScreen");
+  if (attrib_data) xmin = *(unsigned short*)attrib_data;
+  attrib_data = attrib_table->Get("YScreen");
+  if (attrib_data) ymin = *(unsigned short*)attrib_data;
+
+  /* X-orign of image */
+  word_value = xmin;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Y-orign of image */
+  word_value = ymin;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Image Width */
+  word_value = (imushort)this->width;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Image Height */
+  word_value = (imushort)this->height;
+  imBinFileWrite(handle, &word_value, 1, 2); 
+  
+  /* Pixel Depth */
+  imBinFileWrite(handle, &this->bpp, 1, 1);  
+  
+  /* Image Descriptor */
+  byte_value = 0x00;
+  imBinFileWrite(handle, &byte_value, 1, 1);  
+  
+  /* image ID */
+  if (this->id_lenght)
+  {
+    if (length > 255)
+    {
+      imBinFileWrite(handle, (void*)desc_attrib, 254, 1);  
+      byte_value = 0x00;
+      imBinFileWrite(handle, &byte_value, 1, 1);  
+    }
+    else
+      imBinFileWrite(handle, (void*)desc_attrib, this->id_lenght, 1);  
+  }
+  
+  /* tests if everything was ok */
+  if (imBinFileError(handle))
+    return IM_ERR_ACCESS;
+
+  if (this->map_type)
+  {
+    if (!WritePalette())
+      return IM_ERR_ACCESS;
+  }
+  
+  return IM_ERR_NONE;
+}
+
+static long iTGARGB2Color(int c, unsigned char *colors, int map_bpp)
+{
+  unsigned char r,g,b;
+  
+  if (map_bpp == 16)
+  {
+    unsigned short word_value = ((unsigned short*)colors)[c];
+    
+    r = (imbyte)(((word_value & 0x7C00) >> 10)*8);
+    g = (imbyte)(((word_value & 0x03E0) >>  5)*8);
+    b = (imbyte)( (word_value & 0x001F)       *8);
+  }
+  else // 24 or 32
+  {
+    int i = c * (map_bpp / 8);
+    
+    r = colors[i+2];
+    g = colors[i+1];
+    b = colors[i];
+  }
+  
+  return imColorEncode(r, g, b);
+}
+
+int imFileFormatTGA::ReadPalette()
+{
+  int map_size = imFileLineSizeAligned(this->palette_count, this->map_bpp, 1);
+  unsigned char* tga_colors = (unsigned char*) malloc(map_size);
+  
+  /* reads the color palette */
+  imBinFileRead(handle, tga_colors, map_size, 1);
+  if (imBinFileError(handle))
+    return 0;
+
+  if (imBinCPUByteOrder() == IM_BIGENDIAN && this->map_bpp == 16)
+	  imBinSwapBytes2(tga_colors, map_size/2);
+  
+  /* convert the color map to the IM format */
+  for (int c = 0; c < this->palette_count; c++)
+    this->palette[c] = iTGARGB2Color(c, tga_colors, this->map_bpp);
+  
+  free(tga_colors);
+  
+  return 1;
+}
+
+int imFileFormatTGA::WritePalette()
+{
+  unsigned char tga_color[256*3];
+  
+  /* convert the color map from the IM format */
+  for (int c = 0; c < this->palette_count; c++)
+  {
+    int i = 3*c;
+    imColorDecode(&tga_color[i+2], &tga_color[i+1], &tga_color[i], this->palette[c]);
+  }
+  
+  /* writes the color palette */
+  imBinFileWrite(handle, tga_color, this->palette_count * 3, 1);
+
+  if (imBinFileError(handle))
+    return 0;
+  
+  return 1;
+}
+
+int imFileFormatTGA::LoadExtensionArea()
+{
+  unsigned int dword_value;
+  imBinFileSeekFrom(handle, -26);  
+
+  // extension offset
+  imBinFileRead(handle, &dword_value, 1, 4);
+  if (imBinFileError(handle))
+    return 0;
+
+  imBinFileSeekTo(handle, dword_value);  
+  if (imBinFileError(handle))
+    return 0;
+
+  unsigned short word_value;
+  imbyte buffer[512];
+  imAttribTable* attrib_table = AttribTable();
+
+  // extension size
+  imBinFileSeekOffset(handle, 2);  
+
+  // author name
+  imBinFileRead(handle, buffer, 41, 1);
+  if (buffer[0] != 0)
+    attrib_table->Set("Author", IM_BYTE, imStrNLen((char*)buffer, 41)+1, buffer);
+
+  // author comments
+  imBinFileRead(handle, buffer, 324, 1);
+  if (buffer[0] != 0)
+  {
+    int size1 = imStrNLen((char*)buffer, 81);
+    for (int i = 1; i < 4; i++)
+    {
+      int sizei = imStrNLen((char*)buffer + i*81, 81);
+      if (sizei) 
+      {
+        memcpy(buffer + size1, buffer + i*81, sizei);
+        size1 += sizei;
+      }
+    }
+    buffer[size1] = 0;
+
+    attrib_table->Set("Description", IM_BYTE, size1+1, buffer);
+  }
+
+  if (imBinFileError(handle))
+    return 0;
+
+  {
+    tm ttm;
+    ttm.tm_wday = 0;
+    ttm.tm_yday = 0;
+    ttm.tm_isdst = -1;
+
+    int valid = 0;
+    imBinFileRead(handle, &word_value, 1, 2); // moth
+    ttm.tm_mon = word_value-1;
+    if (word_value) valid = 1;
+    imBinFileRead(handle, &word_value, 1, 2); // day
+    ttm.tm_mday = word_value;
+    if (word_value) valid = 1;
+    imBinFileRead(handle, &word_value, 1, 2); // year
+    ttm.tm_year = word_value-1900;
+    if (word_value) valid = 1;
+    imBinFileRead(handle, &word_value, 1, 2); // hour
+    ttm.tm_hour = word_value;
+    imBinFileRead(handle, &word_value, 1, 2); // minute
+    ttm.tm_min = word_value;
+    imBinFileRead(handle, &word_value, 1, 2); // seconds
+    ttm.tm_sec = word_value;
+
+    if (imBinFileError(handle))
+      return 0;
+
+    if (valid)
+    {
+      time_t tt = mktime(&ttm);
+      char* str = ctime(&tt);
+      if (str) 
+      {
+        int size = strlen(str);
+        str[size-1] = 0;   // remove "\n"
+        attrib_table->Set("DateTimeModified", IM_BYTE, size, str);
+      }
+    }
+  }
+
+  // job name
+  imBinFileRead(handle, buffer, 41, 1);
+  if (buffer[0] != 0)
+    attrib_table->Set("JobName", IM_BYTE, imStrNLen((char*)buffer, 41)+1, buffer);
+
+  // job time
+  imBinFileSeekOffset(handle, 6);  
+
+  // Software
+  imBinFileRead(handle, buffer, 41, 1);
+  if (buffer[0] != 0)
+    attrib_table->Set("Software", IM_BYTE, imStrNLen((char*)buffer, 41)+1, buffer);
+
+  if (imBinFileError(handle))
+    return 0;
+
+  // Software Version
+  imBinFileRead(handle, &word_value, 1, 2);
+  if (word_value)
+  {
+    int size = sprintf((char*)buffer, "%f", (double)word_value / 100.0);
+    imBinFileRead(handle, &buffer[size], 1, 1);
+    buffer[size+1] = 0;
+    attrib_table->Set("SoftwareVersion", IM_BYTE, size+1, buffer);
+  }
+
+  // key color, aspect ratio
+  imBinFileSeekOffset(handle, 8); 
+
+  // gamma
+  imBinFileRead(handle, &word_value, 1, 2); // num
+  if (word_value)
+  {
+    float gamma = (float)word_value;
+    imBinFileRead(handle, &word_value, 1, 2); // den
+    if (word_value)
+    {
+      gamma /= (float)word_value;
+      attrib_table->Set("Gamma", IM_FLOAT, 1, &gamma);
+    }
+  }
+
+  if (imBinFileError(handle))
+    return 0;
+
+  return 1;
+}
+
+static void iGetRational(float fvalue, int *num, int *den)
+{
+  if (floorf(fvalue) == fvalue)
+  {
+    *num = (int)floorf(fvalue);
+    *den = 1;
+    return;
+  }
+
+  float ivalue = 1.0f/fvalue;
+  if (floorf(ivalue) == ivalue)
+  {
+    *den = (int)floorf(ivalue);
+    *num = 1;
+    return;
+  }
+
+	*den = 1;
+	if (fvalue > 0) 
+  {
+		while (fvalue < 1L<<(31-3) && *den < 1L<<(31-3))
+    {
+			fvalue *= 1<<3;
+      *den *= 1<<3;
+    }
+	}
+
+	*num = imRound(fvalue);
+}
+
+int imFileFormatTGA::SaveExtensionArea()
+{
+  unsigned int dword_value;
+  unsigned short word_value;
+
+  // get offset before write
+  long ext_offset = imBinFileTell(handle);
+
+  imbyte buffer[512];
+  memset(buffer, 0, 512);
+
+  imAttribTable* attrib_table = AttribTable();
+
+  // extension size
+  word_value = 495;
+  imBinFileWrite(handle, &word_value, 1, 2);
+
+  // author name
+  int attrib_size;
+  const void* attrib_data = attrib_table->Get("Author", NULL, &attrib_size);
+  if (attrib_data)
+  {
+    int size = attrib_size > 41? 40: attrib_size;
+    imBinFileWrite(handle, (void*)attrib_data, size, 1);
+    if (size < 41)
+      imBinFileWrite(handle, buffer, 41-size, 1);
+  }
+  else
+    imBinFileWrite(handle, buffer, 41, 1);
+
+  // author comments
+  attrib_data = attrib_table->Get("Description", NULL, &attrib_size);
+  if (attrib_data)
+  {
+    int size = 0, size2 = 0, i = 0;
+    while(attrib_size && i < 4)
+    {
+      int line_size;
+      if (attrib_size > 81)
+        line_size = 80;
+      else
+        line_size = attrib_size;
+
+      memcpy(buffer + size, (imbyte*)attrib_data + size2, line_size);
+
+      attrib_size -= line_size;
+      size2 += line_size;
+      size += line_size;
+      i++;
+
+      int remain = 81-line_size;
+      if (remain)
+      {
+        memset(buffer + size, 0, remain);
+        size += remain;
+      }
+    }
+
+    imBinFileWrite(handle, buffer, 324, 1);
+    memset(buffer, 0, 512);
+  }
+  else
+    imBinFileWrite(handle, buffer, 324, 1);
+
+  if (imBinFileError(handle))
+    return 0;
+
+  attrib_data = attrib_table->Get("DateTimeModified");
+  if (attrib_data)
+  {
+    time_t cur_time;
+    time(&cur_time);
+    tm* ttm = localtime(&cur_time);
+
+    word_value = (imushort)ttm->tm_mon+1;
+    imBinFileWrite(handle, &word_value, 1, 2); // moth
+    word_value = (imushort)ttm->tm_mday;
+    imBinFileWrite(handle, &word_value, 1, 2); // day
+    word_value = (imushort)ttm->tm_year+1900;
+    imBinFileWrite(handle, &word_value, 1, 2); // year
+    word_value = (imushort)ttm->tm_hour;
+    imBinFileWrite(handle, &word_value, 1, 2); // hour
+    word_value = (imushort)ttm->tm_min;
+    imBinFileWrite(handle, &word_value, 1, 2); // minute
+    word_value = (imushort)ttm->tm_sec;
+    imBinFileWrite(handle, &word_value, 1, 2); // seconds
+
+    if (imBinFileError(handle))
+      return 0;
+  }
+  else
+    imBinFileWrite(handle, buffer, 12, 1);
+
+  // job name
+  attrib_data = attrib_table->Get("JobName", NULL, &attrib_size);
+  if (attrib_data)
+  {
+    int size = attrib_size > 41? 40: attrib_size;
+    imBinFileWrite(handle, (void*)attrib_data, size, 1);
+    if (size < 41)
+      imBinFileWrite(handle, buffer, 41-size, 1);
+  }
+  else
+    imBinFileWrite(handle, buffer, 41, 1);
+
+  // job time
+  imBinFileWrite(handle, buffer, 6, 1);
+
+  // Software
+  attrib_data = attrib_table->Get("Software", NULL, &attrib_size);
+  if (attrib_data)
+  {
+    int size = attrib_size > 41? 40: attrib_size;
+    imBinFileWrite(handle, (void*)attrib_data, size, 1);
+    if (size < 41)
+      imBinFileWrite(handle, buffer, 41-size, 1);
+  }
+  else
+    imBinFileWrite(handle, buffer, 41, 1);
+
+  if (imBinFileError(handle))
+    return 0;
+
+  // Software Version, key color, aspect ratio
+  imBinFileWrite(handle, buffer, 11, 1);
+
+  // gamma
+  attrib_data = attrib_table->Get("Gamma");
+  if (attrib_data)
+  {
+    float gamma = *(float*)attrib_data;
+
+    int num, den;
+    iGetRational(gamma, &num, &den);
+
+    word_value = (imushort)num;
+    imBinFileWrite(handle, &word_value, 1, 2); // num
+    word_value = (imushort)den;
+    imBinFileWrite(handle, &word_value, 1, 2); // den
+  }
+  else
+    imBinFileWrite(handle, buffer, 4, 1);
+
+  // Color Correction, Postage Stamp, Scanline Offset, Attributes Type
+  imBinFileWrite(handle, buffer, 13, 1);
+
+  // FOOTER
+
+  // extension offset
+  dword_value = ext_offset;
+  imBinFileWrite(handle, &dword_value, 1, 4);
+
+  // Developer Directory Offset
+  imBinFileWrite(handle, buffer, 4, 1);
+
+  // signature, reserved, zero string terminator
+  imBinFileWrite(handle, (void*)"TRUEVISION-XFILE.\0", 18, 1);
+
+  if (imBinFileError(handle))
+    return 0;
+
+  return 1;
+}
+
+void imFileFormatTGA::FixRGB()
+{
+  int x;
+  imbyte* byte_data = (imbyte*)this->line_buffer;
+
+  if (this->bpp == 16)
+  {
+    /* inverts the WORD values if not intel */
+    if (imBinCPUByteOrder() == IM_BIGENDIAN)
+      imBinSwapBytes2(this->line_buffer, this->width);
+
+    imushort* word_data = (imushort*)this->line_buffer;
+
+    // from end to start
+    for (x = this->width-1; x >= 0; x--)
+    {
+      imushort word_value = word_data[x];
+      int c = x*3;
+      byte_data[c]   = (imbyte)(((word_value & 0x7C00) >> 10)*8);
+      byte_data[c+1] = (imbyte)(((word_value & 0x03E0) >>  5)*8);
+      byte_data[c+2] = (imbyte)( (word_value & 0x001F)       *8);
+    }
+  }
+  else  // 24 and 32
+  {
+    // convert BGR <-> RGB
+    // convert BGRA <-> RGBA
+    imbyte* byte_data = (imbyte*)this->line_buffer;
+    int planes = this->bpp/8;
+    for (x = 0; x < this->width; x++)
+    {
+      int c = x*planes;
+      imbyte temp = byte_data[c];     // swap R and B
+      byte_data[c] = byte_data[c+2];
+      byte_data[c+2] = temp;
+    }
+  }
+}
+
+int imFileFormatTGA::ReadImageData(void* data)
+{
+  imCounterTotal(this->counter, this->height, "Reading TGA...");
+
+  int line_size = this->line_buffer_size;
+  if (this->bpp == 16)
+    line_size = this->width*2;
+
+  for (int row = 0; row < this->height; row++)
+  {
+    if (this->image_type > 3)
+    {
+      if (iTGADecodeScanLine(handle, (imbyte*)this->line_buffer, this->width, this->bpp/8) == IM_ERR_ACCESS)
+        return IM_ERR_ACCESS;     
+    }
+    else
+    {
+      imBinFileRead(handle, this->line_buffer, line_size, 1);
+      if (imBinFileError(handle))
+        return IM_ERR_ACCESS;     
+    }
+
+    if (this->bpp > 8)
+      FixRGB();
+  
+    imFileLineBufferRead(this, data, row, 0);
+
+    if (!imCounterInc(this->counter))
+      return IM_ERR_COUNTER;
+  }
+  
+  return IM_ERR_NONE;
+}
+
+int imFileFormatTGA::WriteImageData(void* data)
+{
+  imCounterTotal(this->counter, this->height, "Writing TGA...");
+
+  imbyte* compressed_buffer = NULL;
+  if (this->image_type > 3)  // point to the extra buffer
+    compressed_buffer = (imbyte*)this->line_buffer + this->line_buffer_size;
+
+  for (int row = 0; row < this->height; row++)
+  {
+    imFileLineBufferWrite(this, data, row, 0);
+
+    if (this->bpp > 8)
+      FixRGB();
+
+    if (this->image_type > 3)
+    {
+      int compressed_size = iTGAEncodeScanLine(compressed_buffer, (imbyte*)this->line_buffer, this->width, this->bpp/8);
+      imBinFileWrite(handle, compressed_buffer, compressed_size, 1);
+    }
+    else
+    {
+      imBinFileWrite(handle, this->line_buffer, this->line_buffer_size, 1);
+    }
+
+    if (imBinFileError(handle))
+      return IM_ERR_ACCESS;     
+
+    if (!imCounterInc(this->counter))
+      return IM_ERR_COUNTER;
+  }
+
+  if (!SaveExtensionArea())
+    return IM_ERR_ACCESS;     
+
+  return IM_ERR_NONE;
+}
+
+int imFormatTGA::CanWrite(const char* compression, int color_mode, int data_type) const
+{
+  int color_space = imColorModeSpace(color_mode);
+
+  if (color_space == IM_YCBCR || color_space == IM_LAB || 
+      color_space == IM_LUV || color_space == IM_XYZ ||
+      color_space == IM_CMYK)
+    return IM_ERR_DATA;                       
+                                              
+  if (data_type != IM_BYTE)
+    return IM_ERR_DATA;
+
+  if (!compression || compression[0] == 0)
+    return IM_ERR_NONE;
+
+  if (!imStrEqual(compression, "NONE") && !imStrEqual(compression, "RLE"))
+    return IM_ERR_COMPRESS;
+
+  return IM_ERR_NONE;
+}