src/common/imagpcx.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        imagpcx.cpp
   3 // Purpose:     wxImage PCX handler
   4 // Author:      Guillermo Rodriguez Garcia <guille@iies.es>
   5 // Version:     1.1
   6 // CVS-ID:      $Id$
   7 // Copyright:   (c) 1999 Guillermo Rodriguez Garcia
   8 // Licence:     wxWindows licence
   9 /////////////////////////////////////////////////////////////////////////////
  10
  11 #ifdef __GNUG__
  12 #pragma implementation "imagpcx.h"
  13 #endif
  14
  15 // For compilers that support precompilation, includes "wx.h".
  16 #include "wx/wxprec.h"
  17
  18 #ifdef __BORLANDC__
  19 #pragma hdrstop
  20 #endif
  21
  22 #ifndef WX_PRECOMP
  23 #  include "wx/defs.h"
  24 #  include "wx/palette.h"
  25 #endif
  26
  27 #if wxUSE_IMAGE && wxUSE_PCX
  28
  29 #include "wx/imagpcx.h"
  30 #include "wx/wfstream.h"
  31 #include "wx/module.h"
  32 #include "wx/log.h"
  33 #include "wx/intl.h"
  34
  35 #include "wx/hash.h"
  36 #include "wx/list.h"
  37 #include "wx/object.h"
  38
  39 //-----------------------------------------------------------------------------
  40 // wxPCXHandler
  41 //-----------------------------------------------------------------------------
  42
  43 IMPLEMENT_DYNAMIC_CLASS(wxPCXHandler,wxImageHandler)
  44
  45 #if wxUSE_STREAMS
  46
  47 //-----------------------------------------------------------------------------
  48 // RLE encoding and decoding
  49 //-----------------------------------------------------------------------------
  50
  51 void RLEencode(unsigned char *p, unsigned int size, wxOutputStream& s)
  52 {
  53     unsigned int data, last, cont;
  54
  55     // Write 'size' bytes. The PCX official specs say there will be
  56     // a decoding break at the end of each scanline, so in order to
  57     // force this decoding break use this function to write, at most,
  58     // _one_ complete scanline at a time.
  59
  60     last = (unsigned char) *(p++);
  61     cont = 1;
  62     size--;
  63
  64     while (size-- > 0)
  65     {
  66         data = (unsigned char) *(p++);
  67
  68         // Up to 63 bytes with the same value can be stored using
  69         // a single { cont, value } pair.
  70         //
  71         if ((data == last) && (cont < 63))
  72         {
  73             cont++;
  74         }
  75         else
  76         {
  77             // need to write a 'counter' byte?
  78             if ((cont > 1) || ((last & 0xC0) == 0xC0))
  79                 s.PutC((char) (cont | 0xC0));
  80
  81             s.PutC((char) last);
  82             last = data;
  83             cont = 1;
  84         }
  85     }
  86
  87     // write the last one and return;
  88     if ((cont > 1) || ((last & 0xC0) == 0xC0))
  89         s.PutC((char) (cont | 0xC0));
  90
  91     s.PutC((char) last);
  92 }
  93
  94 void RLEdecode(unsigned char *p, unsigned int size, wxInputStream& s)
  95 {
  96     unsigned int i, data, cont;
  97
  98     // Read 'size' bytes. The PCX official specs say there will be
  99     // a decoding break at the end of each scanline (but not at the
 100     // end of each plane inside a scanline). Only use this function
 101     // to read one or more _complete_ scanlines. Else, more than
 102     // 'size' bytes might be read and the buffer might overflow.
 103
 104     while (size > 0)
 105     {
 106         data = (unsigned char)s.GetC();
 107
 108         // If ((data & 0xC0) != 0xC0), then the value read is a data
 109         // byte. Else, it is a counter (cont = val & 0x3F) and the
 110         // next byte is the data byte.
 111                   //
 112         if ((data & 0xC0) != 0xC0)
 113         {
 114             *(p++) = (unsigned char)data;
 115             size--;
 116         }
 117         else
 118         {
 119             cont = data & 0x3F;
 120             data = (unsigned char)s.GetC();
 121             for (i = 1; i <= cont; i++)
 122                 *(p++) = (unsigned char)data;
 123             size -= cont;
 124         }
 125     }
 126 }
 127
 128
 129 //-----------------------------------------------------------------------------
 130 // PCX reading and saving
 131 //-----------------------------------------------------------------------------
 132
 133 // PCX header
 134 #define HDR_MANUFACTURER    0
 135 #define HDR_VERSION         1
 136 #define HDR_ENCODING        2
 137 #define HDR_BITSPERPIXEL    3
 138 #define HDR_XMIN            4
 139 #define HDR_YMIN            6
 140 #define HDR_XMAX            8
 141 #define HDR_YMAX            10
 142 #define HDR_NPLANES         65
 143 #define HDR_BYTESPERLINE    66
 144 #define HDR_PALETTEINFO     68
 145
 146 // image formats
 147 enum {
 148     wxPCX_8BIT,             // 8 bpp, 1 plane (8 bit)
 149     wxPCX_24BIT             // 8 bpp, 3 planes (24 bit)
 150 };
 151
 152 // error codes
 153 enum {
 154     wxPCX_OK = 0,           // everything was OK
 155     wxPCX_INVFORMAT = 1,    // error in pcx file format
 156     wxPCX_MEMERR = 2,       // error allocating memory
 157     wxPCX_VERERR = 3        // error in pcx version number
 158 };
 159
 160
 161 // ReadPCX:
 162 //  Loads a PCX file into the wxImage object pointed by image.
 163 //  Returns wxPCX_OK on success, or an error code otherwise
 164 //  (see above for error codes)
 165 //
 166 int ReadPCX(wxImage *image, wxInputStream& stream)
 167 {
 168     unsigned char hdr[128];         // PCX header
 169     unsigned char pal[768];         // palette for 8 bit images
 170     unsigned char *p;               // space to store one scanline
 171     unsigned char *dst;             // pointer into wxImage data
 172     unsigned int width, height;     // size of the image
 173     unsigned int bytesperline;      // bytes per line (each plane)
 174     int bitsperpixel;               // bits per pixel (each plane)
 175     int nplanes;                    // number of planes
 176     int encoding;                   // is the image RLE encoded?
 177     int format;                     // image format (8 bit, 24 bit)
 178     unsigned int i, j;
 179
 180     // Read PCX header and check the version number (it must
 181     // be at least 5 or higher for 8 bit and 24 bit images).
 182
 183     stream.Read(hdr, 128);
 184
 185     if (hdr[HDR_VERSION] < 5) return wxPCX_VERERR;
 186
 187     // Extract all image info from the PCX header.
 188
 189     encoding     = hdr[HDR_ENCODING];
 190     nplanes      = hdr[HDR_NPLANES];
 191     bitsperpixel = hdr[HDR_BITSPERPIXEL];
 192     bytesperline = hdr[HDR_BYTESPERLINE] + 256 * hdr[HDR_BYTESPERLINE + 1];
 193     width        = (hdr[HDR_XMAX] + 256 * hdr[HDR_XMAX + 1]) -
 194                    (hdr[HDR_XMIN] + 256 * hdr[HDR_XMIN + 1]) + 1;
 195     height       = (hdr[HDR_YMAX] + 256 * hdr[HDR_YMAX + 1]) -
 196                    (hdr[HDR_YMIN] + 256 * hdr[HDR_YMIN + 1]) + 1;
 197
 198     // Check image format. Currently supported formats are
 199     // 8 bits (8 bpp, 1 plane) and 24 bits (8 bpp, 3 planes).
 200
 201     if ((nplanes == 3) && (bitsperpixel == 8))
 202         format = wxPCX_24BIT;
 203     else if ((nplanes == 1) && (bitsperpixel == 8))
 204         format = wxPCX_8BIT;
 205     else
 206         return wxPCX_INVFORMAT;
 207
 208     // If the image is of type wxPCX_8BIT, then there is
 209     // a palette at the end of the image data. If we were
 210     // working with a file, we could seek at the end to the
 211     // end (SeekI(-769, wxFromEnd) and read the palette
 212     // before proceeding. Unfortunately, this would prevent
 213     // loading several PCXs in a single stream, so we can't
 214     // do it. Thus, 8-bit images will have to be decoded in
 215     // two passes: one to read and decode the image data,
 216     // and another to replace 'colour indexes' with RGB
 217     // values.
 218
 219     // Resize the image and allocate memory for a scanline.
 220
 221     image->Create(width, height);
 222
 223     if (!image->Ok())
 224         return wxPCX_MEMERR;
 225
 226     if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
 227         return wxPCX_MEMERR;
 228
 229     // Now start reading the file, line by line, and store
 230     // the data in the format required by wxImage.
 231
 232     dst = image->GetData();
 233
 234     for (j = height; j; j--)
 235     {
 236         if (encoding)
 237             RLEdecode(p, bytesperline * nplanes, stream);
 238         else
 239             stream.Read(p, bytesperline * nplanes);
 240
 241         switch (format)
 242         {
 243             case wxPCX_8BIT:
 244             {
 245                 for (i = 0; i < width; i++)
 246                 {
 247                     // first pass, just store the colour index
 248                     *dst = p[i];
 249                     dst += 3;
 250                 }
 251                 break;
 252             }
 253             case wxPCX_24BIT:
 254             {
 255                 for (i = 0; i < width; i++)
 256                 {
 257                     *(dst++) = p[i];
 258                     *(dst++) = p[i + bytesperline];
 259                     *(dst++) = p[i + 2 * bytesperline];
 260                 }
 261                 break;
 262             }
 263         }
 264     }
 265
 266     free(p);
 267
 268     // For 8 bit images, we read the palette, and then do a second
 269     // pass replacing indexes with their RGB values;
 270
 271     if (format == wxPCX_8BIT)
 272     {
 273         unsigned char index;
 274
 275         if (stream.GetC() != 12)
 276             return wxPCX_INVFORMAT;
 277
 278         stream.Read(pal, 768);
 279
 280         p = image->GetData();
 281         for (unsigned long k = height * width; k; k--)
 282         {
 283             index = *p;
 284             *(p++) = pal[3 * index];
 285             *(p++) = pal[3 * index + 1];
 286             *(p++) = pal[3 * index + 2];
 287         }
 288
 289 #if wxUSE_PALETTE
 290         unsigned char r[256];
 291         unsigned char g[256];
 292         unsigned char b[256];
 293         for (i = 0; i < 256; i++)
 294         {
 295             r[i] = pal[3*i + 0];
 296             g[i] = pal[3*i + 1];
 297             b[i] = pal[3*i + 2];
 298         }
 299         image->SetPalette(wxPalette(256, r, g, b));
 300 #endif // wxUSE_PALETTE
 301     }
 302
 303     return wxPCX_OK;
 304 }
 305
 306 // SavePCX:
 307 //  Saves a PCX file into the wxImage object pointed by image.
 308 //  Returns wxPCX_OK on success, or an error code otherwise
 309 //  (see above for error codes). Will try to save as 8-bit
 310 //  PCX if possible, and then fall back to 24-bit if there
 311 //  are more than 256 different colours.
 312 //
 313 int SavePCX(wxImage *image, wxOutputStream& stream)
 314 {
 315     unsigned char hdr[128];         // PCX header
 316     unsigned char pal[768];         // palette for 8 bit images
 317     unsigned char *p;               // space to store one scanline
 318     unsigned char *src;             // pointer into wxImage data
 319     unsigned int width, height;     // size of the image
 320     unsigned int bytesperline;      // bytes per line (each plane)
 321     int nplanes = 3;                // number of planes
 322     int format = wxPCX_24BIT;       // image format (8 bit, 24 bit)
 323     wxImageHistogram histogram;     // image histogram
 324     unsigned long key;              // key in the hashtable
 325     unsigned int i;
 326
 327     // See if we can save as 8 bit.
 328
 329     if (image->CountColours(256) <= 256)
 330     {
 331         image->ComputeHistogram(histogram);
 332         format = wxPCX_8BIT;
 333         nplanes = 1;
 334     }
 335
 336     // Get image dimensions, calculate bytesperline (must be even,
 337     // according to PCX specs) and allocate space for one complete
 338     // scanline.
 339
 340     if (!image->Ok())
 341         return wxPCX_INVFORMAT;
 342
 343     width = image->GetWidth();
 344     height = image->GetHeight();
 345     bytesperline = width;
 346     if (bytesperline % 2)
 347         bytesperline++;
 348
 349     if ((p = (unsigned char *) malloc(bytesperline * nplanes)) == NULL)
 350         return wxPCX_MEMERR;
 351
 352     // Build header data and write it to the stream. Initially,
 353     // set all bytes to zero (most values default to zero).
 354
 355     memset(hdr, 0, sizeof(hdr));
 356
 357     hdr[HDR_MANUFACTURER]     = 10;
 358     hdr[HDR_VERSION]          = 5;
 359     hdr[HDR_ENCODING]         = 1;
 360     hdr[HDR_NPLANES]          = nplanes;
 361     hdr[HDR_BITSPERPIXEL]     = 8;
 362     hdr[HDR_BYTESPERLINE]     = (unsigned char)(bytesperline % 256);
 363     hdr[HDR_BYTESPERLINE + 1] = (unsigned char)(bytesperline / 256);
 364     hdr[HDR_XMAX]             = (unsigned char)((width - 1)  % 256);
 365     hdr[HDR_XMAX + 1]         = (unsigned char)((width - 1)  / 256);
 366     hdr[HDR_YMAX]             = (unsigned char)((height - 1) % 256);
 367     hdr[HDR_YMAX + 1]         = (unsigned char)((height - 1) / 256);
 368     hdr[HDR_PALETTEINFO]      = 1;
 369
 370     stream.Write(hdr, 128);
 371
 372     // Encode image data line by line and write it to the stream
 373
 374     src = image->GetData();
 375
 376     for (; height; height--)
 377     {
 378         switch (format)
 379         {
 380             case wxPCX_8BIT:
 381             {
 382                 unsigned char r, g, b;
 383
 384                 for (i = 0; i < width; i++)
 385                 {
 386                     r = *(src++);
 387                     g = *(src++);
 388                     b = *(src++);
 389                     key = (r << 16) | (g << 8) | b;
 390
 391                     p[i] = (unsigned char)histogram[key].index;
 392                 }
 393                 break;
 394             }
 395             case wxPCX_24BIT:
 396             {
 397                 for (i = 0; i < width; i++)
 398                 {
 399                     p[i] = *(src++);
 400                     p[i + bytesperline] = *(src++);
 401                     p[i + 2 * bytesperline] = *(src++);
 402                 }
 403                 break;
 404             }
 405         }
 406
 407         RLEencode(p, bytesperline * nplanes, stream);
 408     }
 409
 410     free(p);
 411
 412     // For 8 bit images, build the palette and write it to the stream:
 413     if (format == wxPCX_8BIT)
 414     {
 415         // zero unused colours
 416         memset(pal, 0, sizeof(pal));
 417
 418         unsigned long index;
 419
 420         for (wxImageHistogram::iterator entry = histogram.begin();
 421              entry != histogram.end(); entry++ )
 422         {
 423             key = entry->first;
 424             index = entry->second.index;
 425             pal[3 * index]     = (unsigned char)(key >> 16);
 426             pal[3 * index + 1] = (unsigned char)(key >> 8);
 427             pal[3 * index + 2] = (unsigned char)(key);
 428         }
 429
 430         stream.PutC(12);
 431         stream.Write(pal, 768);
 432     }
 433
 434     return wxPCX_OK;
 435 }
 436
 437 //-----------------------------------------------------------------------------
 438 // wxPCXHandler
 439 //-----------------------------------------------------------------------------
 440
 441 bool wxPCXHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
 442 {
 443     int error;
 444
 445     if (!CanRead(stream))
 446     {
 447         if (verbose)
 448             wxLogError(_("PCX: this is not a PCX file."));
 449
 450         return FALSE;
 451     }
 452
 453     image->Destroy();
 454
 455     if ((error = ReadPCX(image, stream)) != wxPCX_OK)
 456     {
 457         if (verbose)
 458         {
 459             switch (error)
 460             {
 461                 case wxPCX_INVFORMAT: wxLogError(_("PCX: image format unsupported")); break;
 462                 case wxPCX_MEMERR:    wxLogError(_("PCX: couldn't allocate memory")); break;
 463                 case wxPCX_VERERR:    wxLogError(_("PCX: version number too low")); break;
 464                 default:              wxLogError(_("PCX: unknown error !!!"));
 465             }
 466         }
 467         image->Destroy();
 468         return FALSE;
 469     }
 470
 471     return TRUE;
 472 }
 473
 474 bool wxPCXHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 475 {
 476     int error;
 477
 478     if ((error = SavePCX(image, stream)) != wxPCX_OK)
 479     {
 480         if (verbose)
 481         {
 482             switch (error)
 483             {
 484                 case wxPCX_INVFORMAT: wxLogError(_("PCX: invalid image")); break;
 485                 case wxPCX_MEMERR:    wxLogError(_("PCX: couldn't allocate memory")); break;
 486                 default:              wxLogError(_("PCX: unknown error !!!"));
 487             }
 488         }
 489     }
 490
 491     return (error == wxPCX_OK);
 492 }
 493
 494 bool wxPCXHandler::DoCanRead( wxInputStream& stream )
 495 {
 496     unsigned char c = stream.GetC();
 497     if ( !stream )
 498         return FALSE;
 499
 500     // not very safe, but this is all we can get from PCX header :-(
 501     return c == 10;
 502 }
 503
 504 #endif // wxUSE_STREAMS
 505
 506 #endif // wxUSE_IMAGE && wxUSE_PCX
 507