worldspawn/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);
}