2d/pcx.c

   1 /* $Id: pcx.c,v 1.12 2005-07-30 01:51:42 chris Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14 /*
  15  *
  16  * Routines to read/write pcx images.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <conf.h>
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "gr.h"
  29 #include "grdef.h"
  30 #include "u_mem.h"
  31 #include "pcx.h"
  32 #include "cfile.h"
  33
  34 #ifdef OGL
  35 #include "palette.h"
  36 #endif
  37
  38 #include "physfsx.h"
  39
  40 int pcx_encode_byte(ubyte byt, ubyte cnt, PHYSFS_file *fid);
  41 int pcx_encode_line(ubyte *inBuff, int inLen, PHYSFS_file *fp);
  42
  43 /* PCX Header data type */
  44 typedef struct {
  45         ubyte   Manufacturer;
  46         ubyte   Version;
  47         ubyte   Encoding;
  48         ubyte   BitsPerPixel;
  49         short   Xmin;
  50         short   Ymin;
  51         short   Xmax;
  52         short   Ymax;
  53         short   Hdpi;
  54         short   Vdpi;
  55         ubyte   ColorMap[16][3];
  56         ubyte   Reserved;
  57         ubyte   Nplanes;
  58         short   BytesPerLine;
  59         ubyte   filler[60];
  60 } __pack__ PCXHeader;
  61
  62 #define PCXHEADER_SIZE 128
  63
  64 #ifdef FAST_FILE_IO
  65 #define PCXHeader_read_n(ph, n, fp) cfread(ph, sizeof(PCXHeader), n, fp)
  66 #else
  67 /*
  68  * reads n PCXHeader structs from a CFILE
  69  */
  70 int PCXHeader_read_n(PCXHeader *ph, int n, CFILE *fp)
  71 {
  72         int i;
  73
  74         for (i = 0; i < n; i++) {
  75                 ph->Manufacturer = cfile_read_byte(fp);
  76                 ph->Version = cfile_read_byte(fp);
  77                 ph->Encoding = cfile_read_byte(fp);
  78                 ph->BitsPerPixel = cfile_read_byte(fp);
  79                 ph->Xmin = cfile_read_short(fp);
  80                 ph->Ymin = cfile_read_short(fp);
  81                 ph->Xmax = cfile_read_short(fp);
  82                 ph->Ymax = cfile_read_short(fp);
  83                 ph->Hdpi = cfile_read_short(fp);
  84                 ph->Vdpi = cfile_read_short(fp);
  85                 cfread(&ph->ColorMap, 16*3, 1, fp);
  86                 ph->Reserved = cfile_read_byte(fp);
  87                 ph->Nplanes = cfile_read_byte(fp);
  88                 ph->BytesPerLine = cfile_read_short(fp);
  89                 cfread(&ph->filler, 60, 1, fp);
  90         }
  91         return i;
  92 }
  93 #endif
  94
  95 int pcx_get_dimensions( char *filename, int *width, int *height)
  96 {
  97         CFILE *PCXfile;
  98         PCXHeader header;
  99
 100         PCXfile = cfopen(filename, "rb");
 101         if (!PCXfile) return PCX_ERROR_OPENING;
 102
 103         if (PCXHeader_read_n(&header, 1, PCXfile) != 1) {
 104                 cfclose(PCXfile);
 105                 return PCX_ERROR_NO_HEADER;
 106         }
 107         cfclose(PCXfile);
 108
 109         *width = header.Xmax - header.Xmin+1;
 110         *height = header.Ymax - header.Ymin+1;
 111
 112         return PCX_ERROR_NONE;
 113 }
 114
 115 #ifdef MACINTOSH
 116 int pcx_read_bitmap_palette( char *filename, ubyte *palette)
 117 {
 118         PCXHeader header;
 119         CFILE * PCXfile;
 120         ubyte data;
 121         int i;
 122
 123         PCXfile = cfopen( filename , "rb" );
 124         if ( !PCXfile )
 125                 return PCX_ERROR_OPENING;
 126
 127         // read 128 char PCX header
 128         if (PCXHeader_read_n( &header, 1, PCXfile )!=1) {
 129                 cfclose( PCXfile );
 130                 return PCX_ERROR_NO_HEADER;
 131         }
 132         // Is it a 256 color PCX file?
 133         if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))      {
 134                 cfclose( PCXfile );
 135                 return PCX_ERROR_WRONG_VERSION;
 136         }
 137
 138         // Read the extended palette at the end of PCX file
 139         // Read in a character which should be 12 to be extended palette file
 140
 141         if (palette != NULL) {
 142                 cfseek( PCXfile, -768, SEEK_END );
 143                 cfread( palette, 3, 256, PCXfile );
 144                 cfseek( PCXfile, PCXHEADER_SIZE, SEEK_SET );
 145                 for (i=0; i<768; i++ )
 146                         palette[i] >>= 2;
 147 #ifdef MACINTOSH
 148                 for (i = 0; i < 3; i++) {
 149                         data = palette[i];
 150                         palette[i] = palette[765+i];
 151                         palette[765+i] = data;
 152                 }
 153 #endif
 154         }
 155 }
 156 #endif
 157
 158 int pcx_read_bitmap( char * filename, grs_bitmap * bmp,int bitmap_type ,ubyte * palette )
 159 {
 160         PCXHeader header;
 161         CFILE * PCXfile;
 162         int i, row, col, count, xsize, ysize;
 163         ubyte data, *pixdata;
 164
 165         PCXfile = cfopen( filename , "rb" );
 166         if ( !PCXfile )
 167                 return PCX_ERROR_OPENING;
 168
 169         // read 128 char PCX header
 170         if (PCXHeader_read_n( &header, 1, PCXfile )!=1) {
 171                 cfclose( PCXfile );
 172                 return PCX_ERROR_NO_HEADER;
 173         }
 174
 175         // Is it a 256 color PCX file?
 176         if ((header.Manufacturer != 10)||(header.Encoding != 1)||(header.Nplanes != 1)||(header.BitsPerPixel != 8)||(header.Version != 5))      {
 177                 cfclose( PCXfile );
 178                 return PCX_ERROR_WRONG_VERSION;
 179         }
 180
 181         // Find the size of the image
 182         xsize = header.Xmax - header.Xmin + 1;
 183         ysize = header.Ymax - header.Ymin + 1;
 184
 185         if ( bitmap_type == BM_LINEAR ) {
 186                 if ( bmp->bm_data == NULL )     {
 187                         gr_init_bitmap_alloc (bmp, bitmap_type, 0, 0, xsize, ysize, xsize);
 188                 }
 189         }
 190
 191         if ( bmp->bm_type == BM_LINEAR )        {
 192                 for (row=0; row< ysize ; row++)      {
 193                         pixdata = &bmp->bm_data[bmp->bm_rowsize*row];
 194                         for (col=0; col< xsize ; )      {
 195                                 if (cfread( &data, 1, 1, PCXfile )!=1 ) {
 196                                         cfclose( PCXfile );
 197                                         return PCX_ERROR_READING;
 198                                 }
 199                                 if ((data & 0xC0) == 0xC0)     {
 200                                         count =  data & 0x3F;
 201                                         if (cfread( &data, 1, 1, PCXfile )!=1 ) {
 202                                                 cfclose( PCXfile );
 203                                                 return PCX_ERROR_READING;
 204                                         }
 205 #ifdef MACINTOSH
 206                                         if (data == 0)
 207                                                 data = 255;
 208                                         else if (data == 255)
 209                                                 data = 0;
 210 #endif
 211                                         memset( pixdata, data, count );
 212                                         pixdata += count;
 213                                         col += count;
 214                                 } else {
 215 #ifdef MACINTOSH
 216                                         if (data == 0)
 217                                                 data = 255;
 218                                         else if (data == 255)
 219                                                 data = 0;
 220 #endif
 221                                         *pixdata++ = data;
 222                                         col++;
 223                                 }
 224                         }
 225                 }
 226         } else {
 227                 for (row=0; row< ysize ; row++)      {
 228                         for (col=0; col< xsize ; )      {
 229                                 if (cfread( &data, 1, 1, PCXfile )!=1 ) {
 230                                         cfclose( PCXfile );
 231                                         return PCX_ERROR_READING;
 232                                 }
 233                                 if ((data & 0xC0) == 0xC0)     {
 234                                         count =  data & 0x3F;
 235                                         if (cfread( &data, 1, 1, PCXfile )!=1 ) {
 236                                                 cfclose( PCXfile );
 237                                                 return PCX_ERROR_READING;
 238                                         }
 239                                         for (i=0;i<count;i++)
 240                                                 gr_bm_pixel( bmp, col+i, row, data );
 241                                         col += count;
 242                                 } else {
 243                                         gr_bm_pixel( bmp, col, row, data );
 244                                         col++;
 245                                 }
 246                         }
 247                 }
 248         }
 249
 250         // Read the extended palette at the end of PCX file
 251         if ( palette != NULL )  {
 252                 // Read in a character which should be 12 to be extended palette file
 253                 if (cfread( &data, 1, 1, PCXfile )==1)  {
 254                         if ( data == 12 )       {
 255                                 if (cfread(palette,768, 1, PCXfile)!=1) {
 256                                         cfclose( PCXfile );
 257                                         return PCX_ERROR_READING;
 258                                 }
 259                                 for (i=0; i<768; i++ )
 260                                         palette[i] >>= 2;
 261 #ifdef MACINTOSH
 262                                 for (i = 0; i < 3; i++) {
 263                                         data = palette[i];
 264                                         palette[i] = palette[765+i];
 265                                         palette[765+i] = data;
 266                                 }
 267 #endif
 268                         }
 269                 } else {
 270                         cfclose( PCXfile );
 271                         return PCX_ERROR_NO_PALETTE;
 272                 }
 273         }
 274         cfclose(PCXfile);
 275         return PCX_ERROR_NONE;
 276 }
 277
 278 int pcx_write_bitmap( char * filename, grs_bitmap * bmp, ubyte * palette )
 279 {
 280         int retval;
 281         int i;
 282         ubyte data;
 283         PCXHeader header;
 284         PHYSFS_file *PCXfile;
 285
 286         memset( &header, 0, PCXHEADER_SIZE );
 287
 288         header.Manufacturer = 10;
 289         header.Encoding = 1;
 290         header.Nplanes = 1;
 291         header.BitsPerPixel = 8;
 292         header.Version = 5;
 293         header.Xmax = bmp->bm_w-1;
 294         header.Ymax = bmp->bm_h-1;
 295         header.BytesPerLine = bmp->bm_w;
 296
 297         PCXfile = PHYSFSX_openWriteBuffered(filename);
 298         if ( !PCXfile )
 299                 return PCX_ERROR_OPENING;
 300
 301         if (PHYSFS_write(PCXfile, &header, PCXHEADER_SIZE, 1) != 1)
 302         {
 303                 PHYSFS_close(PCXfile);
 304                 return PCX_ERROR_WRITING;
 305         }
 306
 307         for (i=0; i<bmp->bm_h; i++ )    {
 308                 if (!pcx_encode_line( &bmp->bm_data[bmp->bm_rowsize*i], bmp->bm_w, PCXfile ))   {
 309                         PHYSFS_close(PCXfile);
 310                         return PCX_ERROR_WRITING;
 311                 }
 312         }
 313
 314         // Mark an extended palette
 315         data = 12;
 316         if (PHYSFS_write(PCXfile, &data, 1, 1) != 1)
 317         {
 318                 PHYSFS_close(PCXfile);
 319                 return PCX_ERROR_WRITING;
 320         }
 321
 322         // Write the extended palette
 323         for (i=0; i<768; i++ )
 324                 palette[i] <<= 2;
 325
 326         retval = PHYSFS_write(PCXfile, palette, 768, 1);
 327
 328         for (i=0; i<768; i++ )
 329                 palette[i] >>= 2;
 330
 331         if (retval !=1) {
 332                 PHYSFS_close(PCXfile);
 333                 return PCX_ERROR_WRITING;
 334         }
 335
 336         PHYSFS_close(PCXfile);
 337         return PCX_ERROR_NONE;
 338
 339 }
 340
 341 // returns number of bytes written into outBuff, 0 if failed
 342 int pcx_encode_line(ubyte *inBuff, int inLen, PHYSFS_file *fp)
 343 {
 344         ubyte this, last;
 345         int srcIndex, i;
 346         register int total;
 347         register ubyte runCount;        // max single runlength is 63
 348         total = 0;
 349         last = *(inBuff);
 350         runCount = 1;
 351
 352         for (srcIndex = 1; srcIndex < inLen; srcIndex++) {
 353                 this = *(++inBuff);
 354                 if (this == last)       {
 355                         runCount++;                     // it encodes
 356                         if (runCount == 63)     {
 357                                 if (!(i=pcx_encode_byte(last, runCount, fp)))
 358                                         return(0);
 359                                 total += i;
 360                                 runCount = 0;
 361                         }
 362                 } else {        // this != last
 363                         if (runCount)   {
 364                                 if (!(i=pcx_encode_byte(last, runCount, fp)))
 365                                         return(0);
 366                                 total += i;
 367                         }
 368                         last = this;
 369                         runCount = 1;
 370                 }
 371         }
 372
 373         if (runCount)   {               // finish up
 374                 if (!(i=pcx_encode_byte(last, runCount, fp)))
 375                         return 0;
 376                 return total + i;
 377         }
 378         return total;
 379 }
 380
 381 // subroutine for writing an encoded byte pair
 382 // returns count of bytes written, 0 if error
 383 int pcx_encode_byte(ubyte byt, ubyte cnt, PHYSFS_file *fid)
 384 {
 385         if (cnt) {
 386                 if ( (cnt==1) && (0xc0 != (0xc0 & byt)) )       {
 387                         if(EOF == PHYSFSX_putc(fid, (int)byt))
 388                                 return 0;       // disk write error (probably full)
 389                         return 1;
 390                 } else {
 391                         if(EOF == PHYSFSX_putc(fid, (int)0xC0 | cnt))
 392                                 return 0;       // disk write error
 393                         if(EOF == PHYSFSX_putc(fid, (int)byt))
 394                                 return 0;       // disk write error
 395                         return 2;
 396                 }
 397         }
 398         return 0;
 399 }
 400
 401 //text for error messges
 402 char pcx_error_messages[] = {
 403         "No error.\0"
 404         "Error opening file.\0"
 405         "Couldn't read PCX header.\0"
 406         "Unsupported PCX version.\0"
 407         "Error reading data.\0"
 408         "Couldn't find palette information.\0"
 409         "Error writing data.\0"
 410 };
 411
 412
 413 //function to return pointer to error message
 414 char *pcx_errormsg(int error_number)
 415 {
 416         char *p = pcx_error_messages;
 417
 418         while (error_number--) {
 419
 420                 if (!p) return NULL;
 421
 422                 p += strlen(p)+1;
 423
 424         }
 425
 426         return p;
 427
 428 }
 429
 430 // fullscreen loading, 10/14/99 Jan Bobrowski
 431
 432 int pcx_read_fullscr(char * filename, ubyte * palette)
 433 {
 434         int pcx_error;
 435         grs_bitmap bm;
 436         gr_init_bitmap_data(&bm);
 437         pcx_error = pcx_read_bitmap(filename, &bm, BM_LINEAR, palette);
 438         if (pcx_error == PCX_ERROR_NONE) {
 439 #ifdef OGL
 440                 gr_palette_load(palette);
 441 #endif
 442                 show_fullscr(&bm);
 443         }
 444         gr_free_bitmap_data(&bm);
 445         return pcx_error;
 446 }