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