gtkradiant/plugins/image/pcx.cpp

/*
Copyright (C) 1999-2006 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
*/

#include "pcx.h"

#include "ifilesystem.h"

typedef unsigned char byte;

#include <stdlib.h>

#include "imagelib.h"
#include "bytestreamutils.h"

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

PCX LOADING

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

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

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

struct PCXRLEPacket
{
  byte data;
  int length;
};

inline void ByteStream_readPCXRLEPacket(PointerInputStream& inputStream, PCXRLEPacket& packet)
{
  byte d;
  inputStream.read(&d, 1);
  if((d & 0xC0) == 0xC0)
  {
    packet.length = d & 0x3F;
    inputStream.read(&packet.data, 1); 
  }
  else
  {
    packet.length = 1;
    packet.data = d;
  }
}

void LoadPCXBuff(byte* buffer, std::size_t len, byte **pic, byte **palette, int *width, int *height )
{
  *pic = 0;

  pcx_t	pcx;
  int		x, y, lsize;
  byte	*out, *pix;

  /* parse the PCX file */

  PointerInputStream inputStream(buffer);
  
  pcx.manufacturer = istream_read_byte(inputStream);
  pcx.version = istream_read_byte(inputStream);
  pcx.encoding = istream_read_byte(inputStream);
  pcx.bits_per_pixel = istream_read_byte(inputStream);
  pcx.xmin = istream_read_int16_le(inputStream);
  pcx.ymin = istream_read_int16_le(inputStream);
  pcx.xmax = istream_read_int16_le(inputStream);
  pcx.ymax = istream_read_int16_le(inputStream);
  pcx.hres = istream_read_int16_le(inputStream);
  pcx.vres = istream_read_int16_le(inputStream);
  inputStream.read(pcx.palette, 48);
  pcx.reserved = istream_read_byte(inputStream);
  pcx.color_planes = istream_read_byte(inputStream);
  pcx.bytes_per_line = istream_read_int16_le(inputStream);
  pcx.palette_type = istream_read_int16_le(inputStream);
  inputStream.read(pcx.filler, 58);

  
  if (pcx.manufacturer != 0x0a
    || pcx.version != 5
    || pcx.encoding != 1
    || pcx.bits_per_pixel != 8)
    return;

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

  if (!pic)
    return;

  out = (byte *)malloc ( (pcx.ymax+1) * (pcx.xmax+1) );

  *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 */
      PCXRLEPacket packet;
      ByteStream_readPCXRLEPacket(inputStream, packet);
      
      while(packet.length-- > 0)
      {
        pix[ x++ ] = packet.data;
      }
    }

    /* RR2DO2: discard any other data */
    PCXRLEPacket packet;
    while( x < lsize )
    {
      ByteStream_readPCXRLEPacket(inputStream, packet);
      x++;
    }
    while( packet.length-- > 0 )
    {
      x++;
    }
  }
	
  /* validity check */
  if( std::size_t(inputStream.get() - buffer) > len)
  {
    *pic = 0;
  }

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

/*
==============
LoadPCX32
==============
*/
Image* LoadPCX32Buff(byte* buffer, std::size_t length)
{
  byte *palette;
  byte *pic8;
  int i, c, p, width, height;
  byte *pic32;

  LoadPCXBuff(buffer, length, &pic8, &palette, &width, &height);
  if (!pic8)
  {
    return 0;
  }

  RGBAImage* image = new RGBAImage(width, height);
  c = (width) * (height);
  pic32 = image->getRGBAPixels();
  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;
  }

  free (pic8);
  free (palette);

  return image;
}

Image* LoadPCX32(ArchiveFile& file)
{
  ScopedArchiveBuffer buffer(file);
  return LoadPCX32Buff(buffer.buffer, buffer.length);
}