ImageTIFF.cpp

Go to the documentation of this file.

/*
 * ImageTIFF.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy 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.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/FlyLegacy.h"
#include "../Include/Utility.h"
#include "../Include/Globals.h"
#include "../Include/Endian.h"


/*
 * Libtiff implementation
 *
extern "C" {
 #include <tiffio.h>
}
#include <stdarg.h>


static void tiffError (const char* module, const char* fmt, va_list va)
{
  gtfo (fmt, va);
}

static tsize_t tiffRead (thandle_t handle, tdata_t data, tsize_t size)
{
  PODFILE *p = (PODFILE *)handle;
  return pread (data, 1, size, p);
}

static tsize_t tiffWrite (thandle_t handle, tdata_t data, tsize_t size)
{
  gtfo ("tiffWrite : Cannot write to POD file");
  return 0;
}

static toff_t tiffSeek (thandle_t handle, toff_t offset, int origin)
{
  PODFILE *p = (PODFILE *) handle;
  pseek (p, offset, origin);
  return offset;
}

static int tiffClose (thandle_t handle)
{
  PODFILE *p = (PODFILE *) handle;
  pclose (p);
  return 1;
}

static toff_t tiffSize (thandle_t handle)
{
  PODFILE *p = (PODFILE *) handle;
  return p->size;
}

static int tiffMap (thandle_t handle, tdata_t* data, toff_t* offset)
{
//  gtfo ("tiffMap : Unimplemented");
  return 0;
}

static void tiffUnmap (thandle_t handle, tdata_t data, toff_t offset)
{
//  gtfo ("tiffUnmap : Unimplemented");
}


CImageTIFF::CImageTIFF (const char* tifFilename)
{
  // Initialize class members
  image = NULL;
  width = height = 0;
  depth = 4;
  texid = 0;

  // Open POD file
  PODFILE *p = popen (&globals->pfs, tifFilename);
  if (p == NULL) {
    gtfo ("CImageTIFF : Failed to open file %s", tifFilename);
  }

  TIFFSetErrorHandler(tiffError);
  TIFF *tiff = TIFFClientOpen(p->pPod->name, "rb", (thandle_t) p,
    tiffRead, tiffWrite, tiffSeek, tiffClose, tiffSize, tiffMap, tiffUnmap);

  if (tiff) {
    TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
    TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
    size_t nPixels = width * height;
    image = (unsigned char *) _TIFFmalloc (nPixels * sizeof(unsigned long));
    if (image != NULL) {
      if (!TIFFReadRGBAImage (tiff, width, height, (unsigned long *)image, 0)) {
        // Error during read
        gtfo ("CImageTIFF : Error reading image data from %s", tifFilename);
      }
    } else {
      gtfo ("CImageTIFF : Error allocating memory for %s", tifFilename);
    }
  } else {
    gtfo ("CImageTIFF : Error opening TIFF* for %s", tifFilename);
  }

  pclose (p);
}

CImageTIFF::~CImageTIFF (void)
{
  if (image != NULL) _TIFFfree(image);
}

  */


GLuint CImageTIFF::CreateTexture (bool mipmap)
{
  // Create the OpenGL texture
  glGenTextures (1, &texid);
  glBindTexture (GL_TEXTURE_2D, texid);
  glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

  GLenum format = GL_RGBA;
  switch (depth) {
  case 4:
    // RGBA image with opacity data
    format = GL_RGBA;
    break;
  }

  if (mipmap) {
    // Generate mipmapped texture
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

    gluBuild2DMipmaps (GL_TEXTURE_2D, depth, width, height, format,
      GL_UNSIGNED_BYTE, image);
  } else {
    // Generate non-mipmapped texture
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexImage2D (GL_TEXTURE_2D, 0, depth, width, height, 0,
      format, GL_UNSIGNED_BYTE, image);
  }

  return texid;
}

int CImageTIFF::GetWidth (void)
{
  return width;
}

int CImageTIFF::GetHeight (void)
{
  return height;
}


//
// Read data from the TIF stream.  The bigEndian argument is true if
//   data is stored in the file as big-Endian
//
static short tifRead16 (PODFILE *p, bool bigEndian)
{
  short s;
  pread (&s, sizeof(short), 1, p);
  if (bigEndian) {
    s = BigEndian (s);
  } else {
    s = LittleEndian (s);
  }
  return s;
}

static long tifRead32 (PODFILE *p, bool bigEndian)
{
  long v;
  pread (&v, sizeof(long), 1, p);
  if (bigEndian) {
    v = BigEndian (v);
  } else {
    v = LittleEndian (v);
  }
  return v;
}

typedef struct {
  unsigned short    endian;     // 'II' (Little Endian) or 'MM' (Big-Endian)
  unsigned short    signature;  // 0x0042 in appropriate endian-ness
  long              ifd;        // Image File Directory offset
} TIFF_IFH;

typedef struct {
  unsigned short    tag;
  unsigned short    type;
  unsigned long   count;
  unsigned long   offset;
} TIFF_IFD_ENTRY;


#define TIFF_TYPE_BYTE    (1)
#define TIFF_TYPE_ASCII   (2)
#define TIFF_TYPE_SHORT   (3)
#define TIFF_TYPE_LONG    (4)
#define TIFF_TYPE_RATIONAL  (5)

#define TIFF_LITTLE_ENDIAN  (0x4949)
#define TIFF_BIG_ENDIAN   (0x4D4D)
#define TIFF_SIGNATURE    (42)

#define TIFF_TAG_IMAGEWIDTH       (0x0100)
#define TIFF_TAG_IMAGELENGTH      (0x0101)
#define TIFF_TAG_BITSPERSAMPLE      (0x0102)
#define TIFF_TAG_COMPRESSION      (0x0103)
#define TIFF_TAG_INTERPRETATION     (0x0106)
#define TIFF_TAG_STRIPOFFSETS     (0x0111)
#define TIFF_TAG_SAMPLESPERPIXEL    (0x0115)
#define TIFF_TAG_ROWSPERSTRIP     (0x0116)
#define TIFF_TAG_STRIPBYTECOUNTS    (0x0117)
#define TIFF_TAG_PLANARCONFIGURATION  (0x011C)
#define TIFF_TAG_COLORMAP       (0x0140)


typedef enum {
  TIFF_UNKNOWN,
  TIFF_RGB,
  TIFF_CMAP
} ETiffImageType;


CImageTIFF::CImageTIFF (const char* tifFilename)
{
  int i, j, k;
 
  // Locals for image information
  unsigned long   bps = 0;
  unsigned long   spp = 0;
  ETiffImageType  type = TIFF_UNKNOWN;
  unsigned short  num_strips = 0;
  unsigned long  *strip_offsets = NULL;
  unsigned long   rows_per_strip = 0;
  unsigned long  *bytes_per_strip = NULL;
  unsigned long   cmap_size = 0;
  unsigned long   cmap_offset = 0;

  // Initialize class members
  image = NULL;
  width = height = 0;
  texid = 0;

  // Open POD file
  PODFILE *p = popen (&globals->pfs, tifFilename);
  if (p == NULL) {
    gtfo ("CImageTIFF : Failed to open file %s", tifFilename);
  }

  // Read image file header
  TIFF_IFH ifh;
  pread (&ifh, sizeof(TIFF_IFH), 1, p);
  bool bigEndian = false;
  switch (ifh.endian) {
  case TIFF_LITTLE_ENDIAN:
    ifh.signature = LittleEndian (ifh.signature);
    ifh.ifd = LittleEndian (ifh.ifd);
    break;

  case TIFF_BIG_ENDIAN:
    bigEndian = true;
    ifh.signature = BigEndian (ifh.signature);
    ifh.ifd = BigEndian (ifh.ifd);
    break;

  default:
    // Error
    gtfo ("ssgLoadTIF : Invalid endian tag 0x%04X in image file header", ifh.endian);
  }

  // Double-check signature
  if (ifh.signature != TIFF_SIGNATURE) {
    // Error
    gtfo ("ssgLoadTIF : Incorrect TIFF signature");
  }

  // Read number of directory entries
  pseek (p, ifh.ifd, SEEK_SET);
  unsigned short nEntries = (unsigned short) tifRead16 (p, bigEndian);

  // Read directory entries
  TIFF_IFD_ENTRY *entry = new TIFF_IFD_ENTRY[nEntries];
  for (i=0; i<nEntries; i++) {
    TIFF_IFD_ENTRY* ifd = &entry[i];
    ifd->tag = tifRead16 (p, bigEndian);
    ifd->type = tifRead16 (p, bigEndian);
    ifd->count = tifRead32 (p, bigEndian);
    ifd->offset = tifRead32 (p, bigEndian);

    // Parse tag
    switch (ifd->tag) {
    case TIFF_TAG_IMAGEWIDTH:
      // Image width
      switch (ifd->type) {
      case TIFF_TYPE_SHORT:
        width = (short)ifd->offset;
        break;
      case TIFF_TYPE_LONG:
        width = (long)ifd->offset;
        break;
      }
      break;

    case TIFF_TAG_IMAGELENGTH:
      // Image height
      switch (ifd->type) {
      case TIFF_TYPE_SHORT:
        height = (unsigned short)ifd->offset;
        break;
      case TIFF_TYPE_LONG:
        height = (unsigned long)ifd->offset;
        break;
      }
      break;

    case TIFF_TAG_BITSPERSAMPLE:
      // Bits per sample.  For palette images this is typically 8.  For RGB,
      //   it may be 8,8,8 or some other combination of bits for the red,
      //   green and blue channels.
      bps = ifd->offset;
      break;

    case TIFF_TAG_COMPRESSION:
      // Only uncompressed images are supported
      if (ifd->offset != 1) {
        gtfo ("ssgLoadTIF : Compressed images not supported");
      }
      break;

    case TIFF_TAG_INTERPRETATION:
      switch (ifd->offset) {
      case 0:
        // Monochrome, 0 is White
        gtfo ("ssgLoadTIF : Monochrome images not supported");
        break;

      case 1:
        // Monochrome, 0 is Black
        gtfo ("ssgLoadTIF : Monochrome images not supported");
        break;

      case 2:
        // RGB
        type = TIFF_RGB;
        break;

      case 3:
        // Palette color
        type = TIFF_CMAP;
        break;

      case 4:
        // Transparency mask
        gtfo ("ssgLoadTIF : Transparency mask not supported");
        break;
      }
      break;

    case TIFF_TAG_STRIPOFFSETS:
      {
        // Data offsets for each strip
        num_strips = ifd->count;
        strip_offsets = new unsigned long[num_strips];

        if (num_strips == 1) {
          strip_offsets[0] = ifd->offset;
        } else {
          long tell = ptell (p);
          // Set file pointer to read strip offset data
          pseek (p, ifd->offset, SEEK_SET);
          switch (ifd->type) {
          case TIFF_TYPE_SHORT:
            // Offsets are short integers, must be read one at a time and converted to long
            for (j=0; j<num_strips; j++) {
              short s = tifRead16 (p, bigEndian);
              strip_offsets[j] = (long)s;
            }
            break;
          case TIFF_TYPE_LONG:
            // Offsets are long integers
            for (j=0; j<num_strips; j++) {
              strip_offsets[j] = tifRead32 (p, bigEndian);
            }
          }
          // Restore file pointer to read next directory entry
          pseek (p, tell, SEEK_SET);
        }
      }
      break;

    case TIFF_TAG_ROWSPERSTRIP:
      // Number of rows represented by each strip
      rows_per_strip = ifd->offset;
      break;

    case TIFF_TAG_STRIPBYTECOUNTS:
      {
        // Number of bytes in each strip
        num_strips = ifd->count;
        bytes_per_strip = new unsigned long[num_strips];

        if (num_strips == 1) {
          bytes_per_strip[0] = ifd->offset;
        } else {
          long tell = ptell (p);
          pseek (p, ifd->offset, SEEK_SET);
          switch (ifd->type) {
          case TIFF_TYPE_SHORT:
            for (j=0; j<(int)ifd->count; j++) {
              short s = tifRead16 (p, bigEndian);
              bytes_per_strip[j] = (long)s;
            }
            break;
          case TIFF_TYPE_LONG:
            for (j=0; j<(int)ifd->count; j++) {
              bytes_per_strip[j] = tifRead32 (p, bigEndian);
            }
            break;
          }
          // Restore file pointer to read next directory entry
          pseek (p, tell, SEEK_SET);
        }
      }
      break;

    case TIFF_TAG_SAMPLESPERPIXEL:
      // Samples per pixel, only used for RGB images
      spp = ifd->offset;
      break;

    case TIFF_TAG_PLANARCONFIGURATION:
      // Planar configuration for RGB images
      switch (ifd->offset) {
      case 1:
        // Chunky configuration, RGBRGBRGB...
        break;

      case 2:
        // Planar format, not supported
        gtfo ("ssgLoadTIF : Planar format not supported");
        break;
      }
      break;

    case TIFF_TAG_COLORMAP:
      // Color map, only used for palettized images
      // Color map is a table of shorts, all R followed by all G then all B
      cmap_size = ifd->count;
      cmap_offset = ifd->offset;
      break;
    }
  }

  // Verify that an image format was included in the directory entries
  if (type == TIFF_UNKNOWN) {
    gtfo ("ssgLoadTIF : No photometric interpretation type");
  }

  // Allocate storage for the image
  depth = 4;
  image = new GLubyte[width*height*depth];
  memset (image, 0, width*height*depth);

  // Allocate storage for colormap; this is only used if the image is TIFF_CMAP
  typedef struct {
    GLubyte r, g, b;
  } RGB;
  RGB *pal = new RGB[0x100];

  // Read the image data
  switch (type) {
  case TIFF_CMAP:
    {
      // Read the colormap
      pseek (p, cmap_offset, SEEK_SET);
//      long tell = ftell (p->pFile);
      
      // First come all red values
      for (i=0; i<0x100; i++) {
        short s;
        pread (&s, sizeof(short), 1, p);
        pal[i].r = (GLubyte)s;
      }

      // Next all green values
      for (i=0; i<0x100; i++) {
        short s;
        pread (&s, sizeof(short), 1, p);
        pal[i].g = (GLubyte)s;
      }

      // Last all blue values
      for (i=0; i<0x100; i++) {
        short s;
        pread (&s, sizeof(short), 1, p);
        pal[i].b = (GLubyte)s;
      }

      // Read the strip data
      for (i=0; i<num_strips; i++) {
        GLubyte *strip_data = new GLubyte[bytes_per_strip[i]];
        pseek (p, strip_offsets[i], SEEK_SET);
        pread (strip_data, sizeof(GLubyte), bytes_per_strip[i], p);

//        unsigned long bytes_per_row = bytes_per_strip[i] / rows_per_strip;
//        unsigned long pixels_per_strip = bytes_per_strip[i] / spp;
        int iData = 0;
        for (j=0; j<(int)rows_per_strip; j++) {
          for (k=0; k<width; k++) {
            unsigned long imageRow = (i * rows_per_strip) + j;
            unsigned long imageCol = k;
            unsigned long iImage = ((imageRow * width) + imageCol) * depth;

            // Read RGB sample per pixel
            GLubyte pi = strip_data[iData++];
            image [iImage + 0] = pal[pi].r;
            image [iImage + 1] = pal[pi].g;
            image [iImage + 2] = pal[pi].b;

            // If two samples per pixel, read alpha channel
            if (spp == 2) {
              GLubyte a = strip_data[iData++];
              image [iImage + 3] = a;
            } else {
              // No alpha channel
              image [iImage + 3] = 0;
            }
          }
        }
        delete strip_data;
      }
    }

    break;

  case TIFF_RGB:
    // This an RBG image, read the strip data
    break;
    
  default:
    // Unsupported TIF image type
    gtfo ("CImageTIFF : Unsupported TIF image type %d in %s", type, tifFilename);
  }

  // Clean up temporary storage
  delete entry;
  delete pal;
  delete strip_offsets;
  delete bytes_per_strip;

  pclose (p);
}

CImageTIFF::~CImageTIFF (void)
{
  if (image != NULL) delete image;
}

Documentation generated by