src/common/imagpng.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/imagepng.cpp
   3 // Purpose:     wxImage PNG handler
   4 // Author:      Robert Roebling
   5 // RCS-ID:      $Id$
   6 // Copyright:   (c) Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // ============================================================================
  11 // declarations
  12 // ============================================================================
  13
  14 #ifdef __GNUG__
  15 #pragma implementation "imagpng.h"
  16 #endif
  17
  18 // ----------------------------------------------------------------------------
  19 // headers
  20 // ----------------------------------------------------------------------------
  21
  22 // For compilers that support precompilation, includes "wx.h".
  23 #include "wx/wxprec.h"
  24
  25 #ifdef __BORLANDC__
  26   #pragma hdrstop
  27 #endif
  28
  29 #ifndef WX_PRECOMP
  30   #include "wx/defs.h"
  31 #endif
  32
  33 #if wxUSE_IMAGE && wxUSE_LIBPNG
  34
  35 #include "wx/imagpng.h"
  36 #include "wx/bitmap.h"
  37 #include "wx/debug.h"
  38 #include "wx/log.h"
  39 #include "wx/app.h"
  40 #include "png.h"
  41 #include "wx/filefn.h"
  42 #include "wx/wfstream.h"
  43 #include "wx/intl.h"
  44 #include "wx/module.h"
  45
  46 // For memcpy
  47 #include <string.h>
  48
  49 #ifdef __SALFORDC__
  50 #ifdef FAR
  51 #undef FAR
  52 #endif
  53 #endif
  54
  55 // ----------------------------------------------------------------------------
  56 // constants
  57 // ----------------------------------------------------------------------------
  58
  59 // image can not have any transparent pixels at all, have only 100% opaque
  60 // and/or 100% transparent pixels in which case a simple mask is enough to
  61 // store this information in wxImage or have a real alpha channel in which case
  62 // we need to have it in wxImage as well
  63 enum Transparency
  64 {
  65     Transparency_None,
  66     Transparency_Mask,
  67     Transparency_Alpha
  68 };
  69
  70 // ----------------------------------------------------------------------------
  71 // local functions
  72 // ----------------------------------------------------------------------------
  73
  74 // return the kind of transparency needed for this image assuming that it does
  75 // have transparent pixels, i.e. either Transparency_Alpha or Transparency_Mask
  76 static Transparency
  77 CheckTransparency(unsigned char **lines,
  78                   png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
  79                   size_t numColBytes);
  80
  81 // init the alpha channel for the image and fill it with 1s up to (x, y)
  82 static unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y);
  83
  84 // find a free colour for the mask in the PNG data array
  85 static void
  86 FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
  87                unsigned char& rMask, unsigned char& gMask, unsigned char& bMask);
  88
  89 // is the pixel with this value of alpha a fully opaque one?
  90 static inline
  91 bool IsOpaque(unsigned char a)
  92 {
  93     return a == 0xff;
  94 }
  95
  96 // is the pixel with this value of alpha a fully transparent one?
  97 static inline
  98 bool IsTransparent(unsigned char a)
  99 {
 100     return !a;
 101 }
 102
 103 // ============================================================================
 104 // wxPNGHandler implementation
 105 // ============================================================================
 106
 107 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
 108
 109 #if wxUSE_STREAMS
 110
 111 #ifndef PNGLINKAGEMODE
 112     #ifdef __WATCOMC__
 113         // we need an explicit cdecl for Watcom, at least according to
 114         //
 115         // http://sf.net/tracker/index.php?func=detail&aid=651492&group_id=9863&atid=109863
 116         //
 117         // more testing is needed for this however, please remove this comment
 118         // if you can confirm that my fix works with Watcom 11
 119         #define PNGLINKAGEMODE cdecl
 120     #else
 121         #define PNGLINKAGEMODE LINKAGEMODE
 122     #endif
 123 #endif
 124
 125
 126 // VS: wxPNGInfoStruct declared below is a hack that needs some explanation.
 127 //     First, let me describe what's the problem: libpng uses jmp_buf in
 128 //     its png_struct structure. Unfortunately, this structure is
 129 //     compiler-specific and may vary in size, so if you use libpng compiled
 130 //     as DLL with another compiler than the main executable, it may not work
 131 //     (this is for example the case with wxMGL port and SciTech MGL library
 132 //     that provides custom runtime-loadable libpng implementation with jmpbuf
 133 //     disabled altogether). Luckily, it is still possible to use setjmp() &
 134 //     longjmp() as long as the structure is not part of png_struct.
 135 //
 136 //     Sadly, there's no clean way to attach user-defined data to png_struct.
 137 //     There is only one customizable place, png_struct.io_ptr, which is meant
 138 //     only for I/O routines and is set with png_set_read_fn or
 139 //     png_set_write_fn. The hacky part is that we use io_ptr to store
 140 //     a pointer to wxPNGInfoStruct that holds I/O structures _and_ jmp_buf.
 141
 142 struct wxPNGInfoStruct
 143 {
 144     jmp_buf jmpbuf;
 145     bool verbose;
 146
 147     union
 148     {
 149         wxInputStream  *in;
 150         wxOutputStream *out;
 151     } stream;
 152 };
 153
 154 #define WX_PNG_INFO(png_ptr) ((wxPNGInfoStruct*)png_get_io_ptr(png_ptr))
 155
 156 // ----------------------------------------------------------------------------
 157 // helper functions
 158 // ----------------------------------------------------------------------------
 159
 160 extern "C"
 161 {
 162
 163 void PNGLINKAGEMODE _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
 164 {
 165     WX_PNG_INFO(png_ptr)->stream.in->Read(data, length);
 166 }
 167
 168 void PNGLINKAGEMODE _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
 169 {
 170     WX_PNG_INFO(png_ptr)->stream.out->Write(data, length);
 171 }
 172
 173 // from pngerror.c
 174 // so that the libpng doesn't send anything on stderr
 175 void
 176 PNGLINKAGEMODE wx_png_error(png_structp png_ptr, png_const_charp message)
 177 {
 178     wxPNGInfoStruct *info = WX_PNG_INFO(png_ptr);
 179     if (info->verbose)
 180         wxLogError( wxString::FromAscii(message) );
 181
 182 #ifdef USE_FAR_KEYWORD
 183     {
 184        jmp_buf jmpbuf;
 185        png_memcpy(jmpbuf,info->jmpbuf,sizeof(jmp_buf));
 186        longjmp(jmpbuf, 1);
 187     }
 188 #else
 189     longjmp(info->jmpbuf, 1);
 190 #endif
 191 }
 192
 193 void
 194 PNGLINKAGEMODE wx_png_warning(png_structp png_ptr, png_const_charp message)
 195 {
 196     wxPNGInfoStruct *info = WX_PNG_INFO(png_ptr);
 197     if (info->verbose)
 198         wxLogWarning( wxString::FromAscii(message) );
 199 }
 200
 201 } // extern "C"
 202
 203 // ----------------------------------------------------------------------------
 204 // LoadFile() helpers
 205 // ----------------------------------------------------------------------------
 206
 207 // determine the kind of transparency we need for this image: if the only alpha
 208 // values it has are 0 (transparent) and 0xff (opaque) then we can simply
 209 // create a mask for it, we should be ok with a simple mask but otherwise we
 210 // need a full blown alpha channel in wxImage
 211 //
 212 // parameters:
 213 //      lines           raw PNG data
 214 //      x, y            starting position
 215 //      w, h            size of the image
 216 //      numColBytes     number of colour bytes (1 for grey scale, 3 for RGB)
 217 //                      (NB: alpha always follows the colour bytes)
 218 Transparency
 219 CheckTransparency(unsigned char **lines,
 220                   png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
 221                   size_t numColBytes)
 222 {
 223     // we start from (x + 1, y)
 224     x++;
 225
 226     // suppose that a mask will suffice and check all the remaining alpha
 227     // values to see if it does
 228     for ( ; y < h; y++ )
 229     {
 230         unsigned const char *ptr = lines[y] + x;
 231
 232         for ( png_uint_32 x2 = x; x2 < w; x2++ )
 233         {
 234             // skip the grey or colour byte(s)
 235             ptr += numColBytes;
 236
 237             unsigned char a2 = *ptr++;
 238
 239             if ( !IsTransparent(a2) && !IsOpaque(a2) )
 240             {
 241                 // not fully opaque nor fully transparent, hence need alpha
 242                 return Transparency_Alpha;
 243             }
 244         }
 245
 246         // during the next loop iteration check all the pixels in the row
 247         x = 0;
 248     }
 249
 250     // mask will be enough
 251     return Transparency_Mask;
 252 }
 253
 254 unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y)
 255 {
 256     // create alpha channel
 257     image->SetAlpha();
 258
 259     unsigned char *alpha = image->GetAlpha();
 260
 261     // set alpha for the pixels we had so far
 262     png_uint_32 end = y * image->GetWidth() + x;
 263     for ( png_uint_32 i = 0; i < end; i++ )
 264     {
 265         // all the previous pixels were opaque
 266         *alpha++ = 0xff;
 267     }
 268
 269     return alpha;
 270 }
 271
 272 void
 273 FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
 274                unsigned char& rMask, unsigned char& gMask, unsigned char& bMask)
 275 {
 276     // choosing the colour for the mask is more
 277     // difficult: we need to iterate over the entire
 278     // image for this in order to choose an unused
 279     // colour (this is not very efficient but what else
 280     // can we do?)
 281     wxImageHistogram h;
 282     unsigned nentries = 0;
 283     unsigned char r2, g2, b2;
 284     for ( png_uint_32 y2 = 0; y2 < height; y2++ )
 285     {
 286         const unsigned char *p = lines[y2];
 287         for ( png_uint_32 x2 = 0; x2 < width; x2++ )
 288         {
 289             r2 = *p++;
 290             g2 = *p++;
 291             b2 = *p++;
 292
 293             wxImageHistogramEntry&
 294                 entry = h[wxImageHistogram:: MakeKey(r2, g2, b2)];
 295
 296             if ( entry.value++ == 0 )
 297                 entry.index = nentries++;
 298         }
 299     }
 300
 301     if ( !h.FindFirstUnusedColour(&rMask, &gMask, &bMask) )
 302     {
 303         wxLogWarning(_("Too many colours in PNG, the image may be slightly blurred."));
 304
 305         // use a fixed mask colour and we'll fudge
 306         // the real pixels with this colour (see
 307         // below)
 308         rMask = 0xfe;
 309         gMask = 0;
 310         bMask = 0xff;
 311     }
 312 }
 313
 314 // ----------------------------------------------------------------------------
 315 // reading PNGs
 316 // ----------------------------------------------------------------------------
 317
 318 bool wxPNGHandler::DoCanRead( wxInputStream& stream )
 319 {
 320     unsigned char hdr[4];
 321
 322     if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
 323         return FALSE;
 324
 325     return memcmp(hdr, "\211PNG", WXSIZEOF(hdr)) == 0;
 326 }
 327
 328 // convert data from RGB to wxImage format
 329 static
 330 void CopyDataFromPNG(wxImage *image,
 331                      unsigned char **lines,
 332                      png_uint_32 width,
 333                      png_uint_32 height,
 334                      int color_type)
 335 {
 336     Transparency transparency = Transparency_None;
 337
 338     // only non NULL if transparency == Transparency_Alpha
 339     unsigned char *alpha = NULL;
 340
 341     // RGB of the mask colour if transparency == Transparency_Mask
 342     // (but init them anyhow to avoid compiler warnings)
 343     unsigned char rMask = 0,
 344                   gMask = 0,
 345                   bMask = 0;
 346
 347     unsigned char *ptrDst = image->GetData();
 348     if ( !(color_type & PNG_COLOR_MASK_COLOR) )
 349     {
 350         // grey image: GAGAGA... where G == grey component and A == alpha
 351         for ( png_uint_32 y = 0; y < height; y++ )
 352         {
 353             const unsigned char *ptrSrc = lines[y];
 354             for ( png_uint_32 x = 0; x < width; x++ )
 355             {
 356                 unsigned char g = *ptrSrc++;
 357                 unsigned char a = *ptrSrc++;
 358
 359                 // the first time we encounter a transparent pixel we must
 360                 // decide about what to do about them
 361                 if ( !IsOpaque(a) && transparency == Transparency_None )
 362                 {
 363                     // we'll need at least the mask for this image and
 364                     // maybe even full alpha channel info: the former is
 365                     // only enough if we have alpha values of 0 and 0xff
 366                     // only, otherwisewe need the latter
 367                     transparency = CheckTransparency
 368                                    (
 369                                         lines,
 370                                         x, y,
 371                                         width, height,
 372                                         1
 373                                    );
 374
 375                     if ( transparency == Transparency_Mask )
 376                     {
 377                         // let's choose this colour for the mask: this is
 378                         // not a problem here as all the other pixels are
 379                         // grey, i.e. R == G == B which is not the case for
 380                         // this one so no confusion is possible
 381                         rMask = 0xff;
 382                         gMask = 0;
 383                         bMask = 0xff;
 384                     }
 385                     else // transparency == Transparency_Alpha
 386                     {
 387                         alpha = InitAlpha(image, x, y);
 388                     }
 389                 }
 390
 391                 switch ( transparency )
 392                 {
 393                     case Transparency_Mask:
 394                         if ( IsTransparent(a) )
 395                         {
 396                             *ptrDst++ = rMask;
 397                             *ptrDst++ = bMask;
 398                             *ptrDst++ = gMask;
 399                             break;
 400                         }
 401                         // else: !transparent
 402
 403                         // must be opaque then as otherwise we shouldn't be
 404                         // using the mask at all
 405                         wxASSERT_MSG( IsOpaque(a), _T("logic error") );
 406
 407                         // fall through
 408
 409                     case Transparency_Alpha:
 410                         if ( alpha )
 411                             *alpha++ = a;
 412                         // fall through
 413
 414                     case Transparency_None:
 415                         *ptrDst++ = g;
 416                         *ptrDst++ = g;
 417                         *ptrDst++ = g;
 418                         break;
 419                 }
 420             }
 421         }
 422     }
 423     else // colour image: RGBRGB...
 424     {
 425         for ( png_uint_32 y = 0; y < height; y++ )
 426         {
 427             const unsigned char *ptrSrc = lines[y];
 428             for ( png_uint_32 x = 0; x < width; x++ )
 429             {
 430                 unsigned char r = *ptrSrc++;
 431                 unsigned char g = *ptrSrc++;
 432                 unsigned char b = *ptrSrc++;
 433                 unsigned char a = *ptrSrc++;
 434
 435                 // the logic here is the same as for the grey case except
 436                 // where noted
 437                 if ( !IsOpaque(a) && transparency == Transparency_None )
 438                 {
 439                     transparency = CheckTransparency
 440                                    (
 441                                         lines,
 442                                         x, y,
 443                                         width, height,
 444                                         3
 445                                    );
 446
 447                     if ( transparency == Transparency_Mask )
 448                     {
 449                         FindMaskColour(lines, width, height,
 450                                        rMask, gMask, bMask);
 451                     }
 452                     else // transparency == Transparency_Alpha
 453                     {
 454                         alpha = InitAlpha(image, x, y);
 455                     }
 456
 457                 }
 458
 459                 switch ( transparency )
 460                 {
 461                     case Transparency_Mask:
 462                         if ( IsTransparent(a) )
 463                         {
 464                             // if we couldn't find a unique colour for the mask, we
 465                             // can have real pixels with the same value as the mask
 466                             // and it's better to slightly change their colour than
 467                             // to make them transparent
 468                             if ( r == rMask && g == gMask && b == bMask )
 469                             {
 470                                 r++;
 471                             }
 472
 473                             *ptrDst++ = rMask;
 474                             *ptrDst++ = bMask;
 475                             *ptrDst++ = gMask;
 476                             break;
 477                         }
 478                         // else: !transparent
 479
 480                         // must be opaque then as otherwise we shouldn't be
 481                         // using the mask at all
 482                         wxASSERT_MSG( IsOpaque(a), _T("logic error") );
 483
 484                         // fall through
 485
 486                     case Transparency_Alpha:
 487                         if ( alpha )
 488                             *alpha++ = a;
 489                         // fall through
 490
 491                     case Transparency_None:
 492                         *ptrDst++ = r;
 493                         *ptrDst++ = g;
 494                         *ptrDst++ = b;
 495                         break;
 496                 }
 497             }
 498         }
 499     }
 500
 501     if ( transparency == Transparency_Mask )
 502     {
 503         image->SetMaskColour(rMask, gMask, bMask);
 504     }
 505 }
 506
 507 // temporarily disable the warning C4611 (interaction between '_setjmp' and
 508 // C++ object destruction is non-portable) - I don't see any dtors here
 509 #ifdef __VISUALC__
 510     #pragma warning(disable:4611)
 511 #endif /* VC++ */
 512
 513 bool
 514 wxPNGHandler::LoadFile(wxImage *image,
 515                        wxInputStream& stream,
 516                        bool verbose,
 517                        int WXUNUSED(index))
 518 {
 519     // VZ: as this function uses setjmp() the only fool proof error handling
 520     //     method is to use goto (setjmp is not really C++ dtors friendly...)
 521
 522     unsigned char **lines = NULL;
 523     png_infop info_ptr = (png_infop) NULL;
 524     wxPNGInfoStruct wxinfo;
 525
 526     wxinfo.verbose = verbose;
 527     wxinfo.stream.in = &stream;
 528
 529     image->Destroy();
 530
 531     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
 532         (voidp) NULL,
 533         (png_error_ptr) NULL,
 534         (png_error_ptr) NULL );
 535     if (!png_ptr)
 536         goto error;
 537
 538     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 539
 540     // NB: please see the comment near wxPNGInfoStruct declaration for
 541     //     explanation why this line is mandatory
 542     png_set_read_fn( png_ptr, &wxinfo, _PNG_stream_reader);
 543
 544     info_ptr = png_create_info_struct( png_ptr );
 545     if (!info_ptr)
 546         goto error;
 547
 548     if (setjmp(wxinfo.jmpbuf))
 549         goto error;
 550
 551     png_uint_32 i, width, height;
 552     int bit_depth, color_type, interlace_type;
 553
 554     png_read_info( png_ptr, info_ptr );
 555     png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
 556
 557     if (color_type == PNG_COLOR_TYPE_PALETTE)
 558         png_set_expand( png_ptr );
 559
 560     // Fix for Bug [ 439207 ] Monochrome PNG images come up black
 561     if (bit_depth < 8)
 562         png_set_expand( png_ptr );
 563
 564     png_set_strip_16( png_ptr );
 565     png_set_packing( png_ptr );
 566     if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
 567         png_set_expand( png_ptr );
 568     png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
 569
 570     image->Create( (int)width, (int)height );
 571
 572     if (!image->Ok())
 573         goto error;
 574
 575     lines = (unsigned char **)malloc( (size_t)(height * sizeof(unsigned char *)) );
 576     if ( !lines )
 577         goto error;
 578
 579     for (i = 0; i < height; i++)
 580     {
 581         if ((lines[i] = (unsigned char *)malloc( (size_t)(width * (sizeof(unsigned char) * 4)))) == NULL)
 582         {
 583             for ( unsigned int n = 0; n < i; n++ )
 584                 free( lines[n] );
 585             goto error;
 586         }
 587     }
 588
 589     png_read_image( png_ptr, lines );
 590     png_read_end( png_ptr, info_ptr );
 591     png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 592
 593     // loaded successfully, now init wxImage with this data
 594     CopyDataFromPNG(image, lines, width, height, color_type);
 595
 596     for ( i = 0; i < height; i++ )
 597         free( lines[i] );
 598     free( lines );
 599
 600     return TRUE;
 601
 602 error:
 603     if (verbose)
 604        wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
 605
 606     if ( image->Ok() )
 607     {
 608         image->Destroy();
 609     }
 610
 611     if ( lines )
 612     {
 613         free( lines );
 614     }
 615
 616     if ( png_ptr )
 617     {
 618         if ( info_ptr )
 619         {
 620             png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 621             free(info_ptr);
 622         }
 623         else
 624             png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
 625     }
 626     return FALSE;
 627 }
 628
 629 // ----------------------------------------------------------------------------
 630 // writing PNGs
 631 // ----------------------------------------------------------------------------
 632
 633 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 634 {
 635     wxPNGInfoStruct wxinfo;
 636
 637     wxinfo.verbose = verbose;
 638     wxinfo.stream.out = &stream;
 639
 640     png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 641     if (!png_ptr)
 642     {
 643         if (verbose)
 644            wxLogError(_("Couldn't save PNG image."));
 645         return FALSE;
 646     }
 647
 648     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 649
 650     png_infop info_ptr = png_create_info_struct(png_ptr);
 651     if (info_ptr == NULL)
 652     {
 653         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 654         if (verbose)
 655            wxLogError(_("Couldn't save PNG image."));
 656         return FALSE;
 657     }
 658
 659     if (setjmp(wxinfo.jmpbuf))
 660     {
 661         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 662         if (verbose)
 663            wxLogError(_("Couldn't save PNG image."));
 664         return FALSE;
 665     }
 666
 667     // NB: please see the comment near wxPNGInfoStruct declaration for
 668     //     explanation why this line is mandatory
 669     png_set_write_fn( png_ptr, &wxinfo, _PNG_stream_writer, NULL);
 670
 671     png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
 672         PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
 673         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 674
 675     png_color_8 sig_bit;
 676     sig_bit.red = 8;
 677     sig_bit.green = 8;
 678     sig_bit.blue = 8;
 679     sig_bit.alpha = 8;
 680     png_set_sBIT( png_ptr, info_ptr, &sig_bit );
 681     png_write_info( png_ptr, info_ptr );
 682     png_set_shift( png_ptr, &sig_bit );
 683     png_set_packing( png_ptr );
 684
 685     unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
 686     if (!data)
 687     {
 688         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 689         return FALSE;
 690     }
 691
 692     for (int y = 0; y < image->GetHeight(); y++)
 693     {
 694         unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
 695         for (int x = 0; x < image->GetWidth(); x++)
 696         {
 697             data[(x << 2) + 0] = *ptr++;
 698             data[(x << 2) + 1] = *ptr++;
 699             data[(x << 2) + 2] = *ptr++;
 700             if (( !image->HasMask() ) || \
 701                 (data[(x << 2) + 0] != image->GetMaskRed()) || \
 702                 (data[(x << 2) + 1] != image->GetMaskGreen()) || \
 703                 (data[(x << 2) + 2] != image->GetMaskBlue()))
 704             {
 705                 data[(x << 2) + 3] = 255;
 706             }
 707             else
 708             {
 709                 data[(x << 2) + 3] = 0;
 710             }
 711         }
 712         png_bytep row_ptr = data;
 713         png_write_rows( png_ptr, &row_ptr, 1 );
 714     }
 715
 716     free(data);
 717     png_write_end( png_ptr, info_ptr );
 718     png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
 719
 720     return TRUE;
 721 }
 722
 723 #ifdef __VISUALC__
 724     #pragma warning(default:4611)
 725 #endif /* VC++ */
 726
 727 #endif  // wxUSE_STREAMS
 728
 729 #endif  // wxUSE_LIBPNG