gtkradiant/plugins/image/lbmlib.cpp

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.

This file is part of GtkRadiant.

GtkRadiant 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.

GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

// lbmlib.c

#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "image.h"
#include "lbmlib.h"
#include "bmp.h"

#define LittleLong(a) GINT32_FROM_LE(a)
#define LittleShort(a) GINT16_FROM_LE(a)

#include <stdio.h>

#define Sys_Printf g_FuncTable.m_pfnSysPrintf
#define Sys_FPrintf g_FuncTable.m_pfnSysFPrintf

/*
============================================================================

LOAD PCX

============================================================================
*/
typedef struct
{
  char manufacturer;
  char version;
  char encoding;
  char bits_per_pixel;
  unsigned short xmin, ymin, xmax, ymax;
  unsigned short hres, vres;
  unsigned char palette[48];
  char reserved;
  char color_planes;
  unsigned short bytes_per_line;
  unsigned short palette_type;
  char filler[58];
  unsigned char data;		// unbounded
} pcx_t;

/*
============================================================================

TARGA IMAGE

============================================================================
*/
typedef struct _TargaHeader
{
  unsigned char id_length, colormap_type, image_type;
  unsigned short colormap_index, colormap_length;
  unsigned char colormap_size;
  unsigned short x_origin, y_origin, width, height;
  unsigned char pixel_size, attributes;
} TargaHeader;

/*
=========================================================

BMP LOADING

=========================================================
*/
typedef struct
{
  char id[2];
  unsigned long fileSize;
  unsigned long reserved0;
  unsigned long bitmapDataOffset;
  unsigned long bitmapHeaderSize;
  unsigned long width;
  unsigned long height;
  unsigned short planes;
  unsigned short bitsPerPixel;
  unsigned long compression;
  unsigned long bitmapDataSize;
  unsigned long hRes;
  unsigned long vRes;
  unsigned long colors;
  unsigned long importantColors;
  unsigned char palette[256][4];
} BMPHeader_t;

static void LoadBMP (const char *name, byte ** pic, int *width, int *height)
{
  int columns, rows, numPixels;
  byte *pixbuf;
  int row, column;
  byte *buf_p;
  byte *buffer;
  unsigned int length;
  BMPHeader_t bmpHeader;
  byte *bmpRGBA;

  *pic = NULL;

  //
  // load the file
  //
  length = vfsLoadFile( (char *)name, (void **)&buffer, 0 );
  if (length == (unsigned int) -1)
    return;

  buf_p = buffer;

  bmpHeader.id[0] = *buf_p++;
  bmpHeader.id[1] = *buf_p++;
  bmpHeader.fileSize = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.reserved0 = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.bitmapDataOffset = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.bitmapHeaderSize = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.width = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.height = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.planes = LittleShort (*(short *) buf_p);
  buf_p += 2;
  bmpHeader.bitsPerPixel = LittleShort (*(short *) buf_p);
  buf_p += 2;
  bmpHeader.compression = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.bitmapDataSize = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.hRes = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.vRes = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.colors = LittleLong (*(long *) buf_p);
  buf_p += 4;
  bmpHeader.importantColors = LittleLong (*(long *) buf_p);
  buf_p += 4;

  memcpy (bmpHeader.palette, buf_p, sizeof (bmpHeader.palette));

  if (bmpHeader.bitsPerPixel == 8)
    buf_p += 1024;

  if (bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M')
  {
    Sys_Printf ("LoadBMP: only Windows-style BMP files supported (%s)\n", name);
    return;
  }
  if (bmpHeader.fileSize != length)
  {
    Sys_Printf ("LoadBMP: header size does not match file size (%d vs. %d) (%s)\n",
		bmpHeader.fileSize, length, name);
    return;
  }
  if (bmpHeader.compression != 0)
  {
    Sys_Printf ("LoadBMP: only uncompressed BMP files supported (%s)\n", name);
    return;
  }
  if (bmpHeader.bitsPerPixel < 8)
  {
    Sys_Printf ("LoadBMP: monochrome and 4-bit BMP files not supported (%s)\n", name);
    return;
  }

  columns = bmpHeader.width;
  rows = bmpHeader.height;
  if (rows < 0)
    rows = -rows;
  numPixels = columns * rows;

  if (width)
    *width = columns;
  if (height)
    *height = rows;

  bmpRGBA = reinterpret_cast < unsigned char *>(g_malloc (numPixels * 4));
  *pic = bmpRGBA;


  for (row = rows - 1; row >= 0; row--)
  {
    pixbuf = bmpRGBA + row * columns * 4;

    for (column = 0; column < columns; column++)
    {
      unsigned char red, green, blue, alpha;
      int palIndex;
      unsigned short shortPixel;

      switch (bmpHeader.bitsPerPixel)
      {
      case 8:
        palIndex = *buf_p++;
        *pixbuf++ = bmpHeader.palette[palIndex][2];
        *pixbuf++ = bmpHeader.palette[palIndex][1];
        *pixbuf++ = bmpHeader.palette[palIndex][0];
        *pixbuf++ = 0xff;
        break;
      case 16:
        shortPixel = *(unsigned short *) pixbuf;
        pixbuf += 2;
        *pixbuf++ = (shortPixel & (31 << 10)) >> 7;
        *pixbuf++ = (shortPixel & (31 << 5)) >> 2;
        *pixbuf++ = (shortPixel & (31)) << 3;
        *pixbuf++ = 0xff;
        break;
      case 24:
        blue = *buf_p++;
        green = *buf_p++;
        red = *buf_p++;
        *pixbuf++ = red;
        *pixbuf++ = green;
        *pixbuf++ = blue;
        *pixbuf++ = 255;
        break;
      case 32:
        blue = *buf_p++;
        green = *buf_p++;
        red = *buf_p++;
        alpha = *buf_p++;
        *pixbuf++ = red;
        *pixbuf++ = green;
        *pixbuf++ = blue;
        *pixbuf++ = alpha;
        break;
      default:
        Sys_Printf ("LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel,
              name);
        g_free (*pic);
        *pic = NULL;
        return;
        break;
      }
    }
  }

  vfsFreeFile (buffer);

}


/*
=================================================================

PCX LOADING

=================================================================
*/


/*
==============
LoadPCX
==============
*/

/* RR2DO2 */
#define DECODEPCX( b, d, r ) d=*b++;if((d&0xC0)==0xC0){r=d&0x3F;d=*b++;}else{r=1;}

static void LoadPCX( const char *filename, byte **pic, byte **palette, int *width, int *height )
{
  byte	*raw;
  pcx_t	*pcx;
  int		x, y, lsize;
  int		len;
  int		dataByte, runLength;
  byte	*out, *pix;
	

  /* load the file */
  len = vfsLoadFile (filename, (void **)&raw, 0);
  if( len == -1 ) 
    Error( "LoadPCX: Couldn't read %s", filename );


  /* parse the PCX file */
  pcx = (pcx_t *)raw;
  raw = &pcx->data;
  
  pcx->xmin = LittleShort(pcx->xmin);
  pcx->ymin = LittleShort(pcx->ymin);
  pcx->xmax = LittleShort(pcx->xmax);
  pcx->ymax = LittleShort(pcx->ymax);
  pcx->hres = LittleShort(pcx->hres);
  pcx->vres = LittleShort(pcx->vres);
  pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
  pcx->palette_type = LittleShort(pcx->palette_type);
  
  if (pcx->manufacturer != 0x0a
    || pcx->version != 5
    || pcx->encoding != 1
    || pcx->bits_per_pixel != 8
    || pcx->xmax >= 640
    || pcx->ymax >= 480)
    Error ("Bad pcx file %s", filename);

  if (palette)
  {
    *palette = (byte *)malloc(768);
    memcpy (*palette, (byte *)pcx + len - 768, 768);
  }

  if (width)
    *width = pcx->xmax+1;
  if (height)
    *height = pcx->ymax+1;

  if (!pic)
    return;

  out = (byte *)malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
  if (!out)
    Error( "LoadPCX: couldn't allocate");

  *pic = out;
  pix = out;
	
  /* RR2DO2: pcx fix  */
  lsize = pcx->color_planes * pcx->bytes_per_line;
	
  /* go scanline by scanline */
  for( y = 0; y <= pcx->ymax; y++, pix += pcx->xmax + 1 )
  {
    /* do a scanline */
    for( x=0; x <= pcx->xmax; )
    {
      /* RR2DO2 */
      DECODEPCX( raw, dataByte, runLength );
      while( runLength-- > 0 )
        pix[ x++ ] = dataByte;
    }

    /* RR2DO2: discard any other data */
    while( x < lsize )
    {
      DECODEPCX( raw, dataByte, runLength );
      x++;
    }
    while( runLength-- > 0 )
      x++;
  }
	
  /* validity check */
  if( raw - (byte *) pcx > len)
    Error( "PCX file %s was malformed", filename );
  free( pcx );
}

/*
==============
LoadPCX32
==============
*/
static void LoadPCX32 (const char *filename, byte ** pic, int *width, int *height)
{
  byte *palette;
  byte *pic8;
  int i, c, p;
  byte *pic32;

  LoadPCX (filename, &pic8, &palette, width, height);
  if (!pic8)
  {
    *pic = NULL;
    return;
  }

  c = (*width) * (*height);
  pic32 = *pic = reinterpret_cast < unsigned char *>(g_malloc (4 * c));
  for (i = 0; i < c; i++)
  {
    p = pic8[i];
    pic32[0] = palette[p * 3];
    pic32[1] = palette[p * 3 + 1];
    pic32[2] = palette[p * 3 + 2];
    pic32[3] = 255;
    pic32 += 4;
  }

  g_free (pic8);
  g_free (palette);
}

/*
=========================================================

TARGA LOADING

  TTimo: added code to get rid of alphachannel from prefs or ignore it if completely empty
    was required since Radiant is using alpha channel when binding the textures for proper curry operation
    can be fully turned off from the prefs though
=========================================================
*/

/*
=============
LoadTGA
=============
*/
void LoadTGA (const char *name, byte ** pic, int *width, int *height)
{
  int columns, rows, numPixels;
  byte *pixbuf;
  int row, column;
  byte *buf_p;
  byte *buffer;
  TargaHeader targa_header;
  byte *targa_rgba;

  *pic = NULL;

  //
  // load the file
  //
  int nLen = vfsLoadFile( (char *)name, (void **)&buffer, 0 );
  if (nLen == -1)
    return;

  buf_p = buffer;

  targa_header.id_length = *buf_p++;
  targa_header.colormap_type = *buf_p++;
  targa_header.image_type = *buf_p++;

  targa_header.colormap_index = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.colormap_length = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.colormap_size = *buf_p++;
  targa_header.x_origin = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.y_origin = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.width = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.height = LittleShort (*(short *) buf_p);
  buf_p += 2;
  targa_header.pixel_size = *buf_p++;
  targa_header.attributes = *buf_p++;

  bool bAlphaOK = false;

  if (targa_header.image_type != 2 && targa_header.image_type != 10 && targa_header.image_type != 3)
  {
    Sys_Printf ("LoadTGA: TGA type %d not supported\n", targa_header.image_type);
    Sys_Printf ("LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n");
    return;
  }

  if (targa_header.colormap_type != 0)
  {
    Sys_Printf ("LoadTGA: colormaps not supported\n");
    return;
  }

  if ((targa_header.pixel_size != 32 && targa_header.pixel_size != 24)
      && targa_header.image_type != 3)
  {
    Sys_Printf ("LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
    return;
  }

  columns = targa_header.width;
  rows = targa_header.height;
  numPixels = columns * rows;

  if (width)
    *width = columns;
  if (height)
    *height = rows;

  targa_rgba = reinterpret_cast < unsigned char *>(g_malloc (numPixels * 4));
  *pic = targa_rgba;

  if (targa_header.id_length != 0)
    buf_p += targa_header.id_length;	// skip TARGA image comment

  if (targa_header.image_type == 2 || targa_header.image_type == 3)
  {
    // Uncompressed RGB or gray scale image
    for (row = rows - 1; row >= 0; row--)
    {
      pixbuf = targa_rgba + row * columns * 4;
      for (column = 0; column < columns; column++)
      {
        unsigned char red, green, blue, alphabyte;
        switch (targa_header.pixel_size)
        {
          case 8:
            blue = *buf_p++;
            green = blue;
            red = blue;
            *pixbuf++ = red;
            *pixbuf++ = green;
            *pixbuf++ = blue;
            *pixbuf++ = 255;
            break;
          
          case 24:
            blue = *buf_p++;
            green = *buf_p++;
            red = *buf_p++;
            *pixbuf++ = red;
            *pixbuf++ = green;
            *pixbuf++ = blue;
            *pixbuf++ = 255;
            break;
          case 32:
            blue = *buf_p++;
            green = *buf_p++;
            red = *buf_p++;
            alphabyte = *buf_p++;
            // detect if the whole alpha channel is 0
            if (alphabyte != 0)
              bAlphaOK = true;
            *pixbuf++ = red;
            *pixbuf++ = green;
            *pixbuf++ = blue;
            *pixbuf++ = alphabyte;
            break;
          default:
            Sys_Printf ("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size,
                  name);
            g_free (*pic);
            *pic = NULL;
            return;
            break;
        }
      }
    }

    if (!bAlphaOK)
    {
      // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=444
      if (targa_header.pixel_size == 32) 
				Sys_FPrintf (SYS_WRN, "WARNING: %s has empty alpha channel\n", name);
      // disable the alpha value
      for (row = rows - 1; row >= 0; row--)
      {
        pixbuf = targa_rgba + row * columns * 4;
        for (column = 0; column < columns; column++)
        {
          // 32 bit
          pixbuf += 3;
          *pixbuf++ = 255;
        }
      }
    }
  }
  else if (targa_header.image_type == 10)
  {				// Runlength encoded RGB images
    unsigned char red, green, blue, alphabyte, packetHeader, packetSize, j;

    red = 0;
    green = 0;
    blue = 0;
    alphabyte = 0xff;

    for (row = rows - 1; row >= 0; row--)
    {
      pixbuf = targa_rgba + row * columns * 4;
      for (column = 0; column < columns;)
      {
        packetHeader = *buf_p++;
        packetSize = 1 + (packetHeader & 0x7f);
        if (packetHeader & 0x80)
        {			// run-length packet
          switch (targa_header.pixel_size)
          {
          case 24:
            blue = *buf_p++;
            green = *buf_p++;
            red = *buf_p++;
            alphabyte = 255;
            break;
          case 32:
            blue = *buf_p++;
            green = *buf_p++;
            red = *buf_p++;
            alphabyte = *buf_p++;
            // detect if the whole alpha channel is 0
            if (alphabyte != 0)
              bAlphaOK = true;
            break;
          default:
            Sys_Printf ("LoadTGA: illegal pixel_size '%d' in file '%s'\n", targa_header.pixel_size,
            name);
            g_free (*pic);
            *pic = NULL;
            return;
            break;
          }

          for (j = 0; j < packetSize; j++)
          {
            *pixbuf++ = red;
            *pixbuf++ = green;
            *pixbuf++ = blue;
                  *pixbuf++ = alphabyte;
            column++;
            if (column == columns)
            {			// run spans across rows
              column = 0;
              if (row > 0)
                row--;
              else
                goto breakOut;
            pixbuf = targa_rgba + row * columns * 4;
            }
          }
        }
        else
        {			// non run-length packet
          for (j = 0; j < packetSize; j++)
          {
            switch (targa_header.pixel_size)
            {
              case 24:
                blue = *buf_p++;
                green = *buf_p++;
                red = *buf_p++;
                *pixbuf++ = red;
                *pixbuf++ = green;
                *pixbuf++ = blue;
                *pixbuf++ = 255;
                break;
              case 32:
                blue = *buf_p++;
                green = *buf_p++;
                red = *buf_p++;
                alphabyte = *buf_p++;
                // detect if the whole alpha channel is 0
                if (alphabyte != 0)
                  bAlphaOK = true;
                *pixbuf++ = red;
                *pixbuf++ = green;
                *pixbuf++ = blue;
                *pixbuf++ = alphabyte;
                break;
              default:
                Sys_Printf ("LoadTGA: illegal pixel_size '%d' in file '%s'\n",
                targa_header.pixel_size, name);
                g_free (*pic);
                *pic = NULL;
                return;
                break;
            }
            column++;
            if (column == columns)
            {			// pixel packet run spans across rows
              column = 0;
              if (row > 0)
                row--;
              else
                goto breakOut;
              pixbuf = targa_rgba + row * columns * 4;
            }
          }
        }
      }
    breakOut:;
    }

    if (!bAlphaOK)
    {
      if (targa_header.pixel_size == 32)
        Sys_FPrintf (SYS_WRN, "WARNING: %s has empty alpha channel\n", name);
      // disable the alpha value
      for (row = rows - 1; row >= 0; row--)
      {
        pixbuf = targa_rgba + row * columns * 4;
        for (column = 0; column < columns; column++)
        {
          // 32 bit
          pixbuf += 3;
          *pixbuf++ = 255;
        }
      }
    }

  }

  // vertically flipped
  if ( (targa_header.attributes & (1<<5)) ) {
    int flip;
    for (row = 0; row < .5f * rows; row++)
    {
      for (column = 0; column < columns; column++)
      {
        flip = *( (int*)targa_rgba + row * columns + column);
		*( (int*)targa_rgba + row * columns + column) = *( (int*)targa_rgba + ( ( rows - 1 ) - row ) * columns + column );
		*( (int*)targa_rgba + ( ( rows - 1 ) - row ) * columns + column ) = flip;
	  }
	}
  }

  vfsFreeFile (buffer);
}

//===================================================================

/*
=================
LoadImage

Loads any of the supported image types into a cannonical
32 bit format.
=================
*/
void LoadImage (const char *name, byte ** pic, int *width, int *height)
{
  int len;
  *pic = NULL;
  *width = 0;
  *height = 0;

  len = strlen (name);
  if (len < 5)
  {
    return;
  }

  if (!g_strcasecmp (name + len - 4, ".tga"))
  {
    LoadTGA (name, pic, width, height);
  }
  else if (!g_strcasecmp (name + len - 4, ".pcx"))
  {
    LoadPCX32 (name, pic, width, height);
  }
  else if (!g_strcasecmp (name + len - 4, ".bmp"))
  {
    LoadBMP (name, pic, width, height);
  }
  /*
  else if (!g_strcasecmp (name + len - 4, ".jpg"))
  {
    LoadJPG (name, pic, width, height);
  }
  */
}