mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-11-27 14:12:11 +00:00
12b372f89c
git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant@1 8a3a26a2-13c4-0310-b231-cf6edde360e5
222 lines
4.8 KiB
C++
222 lines
4.8 KiB
C++
/*
|
|
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);
|
|
}
|
|
|