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(const unsigned char *ptr,
  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 //      ptr             the start of the data to examine
 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(const unsigned char *ptr,
 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     unsigned const char *ptr2 = ptr;
 229     for ( png_uint_32 y2 = y; y2 < h; y2++ )
 230     {
 231         for ( png_uint_32 x2 = x; x2 < w; x2++ )
 232         {
 233             // skip the grey or colour byte(s)
 234             ptr2 += numColBytes;
 235
 236             unsigned char a2 = *ptr2++;
 237
 238             if ( !IsTransparent(a2) && !IsOpaque(a2) )
 239             {
 240                 // not fully opaque nor fully transparent, hence need alpha
 241                 return Transparency_Alpha;
 242             }
 243         }
 244
 245         // during the next loop iteration check all the pixels in the row
 246         x = 0;
 247     }
 248
 249     // mask will be enough
 250     return Transparency_Mask;
 251 }
 252
 253 unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y)
 254 {
 255     // create alpha channel
 256     image->SetAlpha();
 257
 258     unsigned char *alpha = image->GetAlpha();
 259
 260     // set alpha for the pixels we had so far
 261     png_uint_32 end = y * image->GetWidth() + x;
 262     for ( png_uint_32 i = 0; i < end; i++ )
 263     {
 264         // all the previous pixels were opaque
 265         *alpha++ = 0xff;
 266     }
 267
 268     return alpha;
 269 }
 270
 271 void
 272 FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
 273                unsigned char& rMask, unsigned char& gMask, unsigned char& bMask)
 274 {
 275     // choosing the colour for the mask is more
 276     // difficult: we need to iterate over the entire
 277     // image for this in order to choose an unused
 278     // colour (this is not very efficient but what else
 279     // can we do?)
 280     wxImageHistogram h;
 281     unsigned nentries = 0;
 282     unsigned char r2, g2, b2;
 283     for ( png_uint_32 y2 = 0; y2 < height; y2++ )
 284     {
 285         const unsigned char *p = lines[y2];
 286         for ( png_uint_32 x2 = 0; x2 < width; x2++ )
 287         {
 288             r2 = *p++;
 289             g2 = *p++;
 290             b2 = *p++;
 291
 292             wxImageHistogramEntry&
 293                 entry = h[wxImageHistogram:: MakeKey(r2, g2, b2)];
 294
 295             if ( entry.value++ == 0 )
 296                 entry.index = nentries++;
 297         }
 298     }
 299
 300     if ( !h.FindFirstUnusedColour(&rMask, &gMask, &bMask) )
 301     {
 302         wxLogWarning(_("Too many colours in PNG, the image may be slightly blurred."));
 303
 304         // use a fixed mask colour and we'll fudge
 305         // the real pixels with this colour (see
 306         // below)
 307         rMask = 0xfe;
 308         gMask = 0;
 309         bMask = 0xff;
 310     }
 311 }
 312
 313 // ----------------------------------------------------------------------------
 314 // reading PNGs
 315 // ----------------------------------------------------------------------------
 316
 317 bool wxPNGHandler::DoCanRead( wxInputStream& stream )
 318 {
 319     unsigned char hdr[4];
 320
 321     if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
 322         return FALSE;
 323
 324     return memcmp(hdr, "\211PNG", WXSIZEOF(hdr)) == 0;
 325 }
 326
 327 // convert data from RGB to wxImage format
 328 static
 329 void CopyDataFromPNG(wxImage *image,
 330                      unsigned char **lines,
 331                      png_uint_32 width,
 332                      png_uint_32 height,
 333                      int color_type)
 334 {
 335     Transparency transparency = Transparency_None;
 336
 337     // only non NULL if transparency == Transparency_Alpha
 338     unsigned char *alpha = NULL;
 339
 340     // RGB of the mask colour if transparency == Transparency_Mask
 341     // (but init them anyhow to avoid compiler warnings)
 342     unsigned char rMask = 0,
 343                   gMask = 0,
 344                   bMask = 0;
 345
 346     unsigned char *ptrDst = image->GetData();
 347     if ( !(color_type & PNG_COLOR_MASK_COLOR) )
 348     {
 349         // grey image: GAGAGA... where G == grey component and A == alpha
 350         for ( png_uint_32 y = 0; y < height; y++ )
 351         {
 352             const unsigned char *ptrSrc = lines[y];
 353             for ( png_uint_32 x = 0; x < width; x++ )
 354             {
 355                 unsigned char g = *ptrSrc++;
 356                 unsigned char a = *ptrSrc++;
 357
 358                 // the first time we encounter a transparent pixel we must
 359                 // decide about what to do about them
 360                 if ( !IsOpaque(a) && transparency == Transparency_None )
 361                 {
 362                     // we'll need at least the mask for this image and
 363                     // maybe even full alpha channel info: the former is
 364                     // only enough if we have alpha values of 0 and 0xff
 365                     // only, otherwisewe need the latter
 366                     transparency = CheckTransparency
 367                                    (
 368                                         ptrSrc,
 369                                         x, y,
 370                                         width, height,
 371                                         1
 372                                    );
 373
 374                     if ( transparency == Transparency_Mask )
 375                     {
 376                         // let's choose this colour for the mask: this is
 377                         // not a problem here as all the other pixels are
 378                         // grey, i.e. R == G == B which is not the case for
 379                         // this one so no confusion is possible
 380                         rMask = 0xff;
 381                         gMask = 0;
 382                         bMask = 0xff;
 383                     }
 384                     else // transparency == Transparency_Alpha
 385                     {
 386                         alpha = InitAlpha(image, x, y);
 387                     }
 388                 }
 389
 390                 switch ( transparency )
 391                 {
 392                     case Transparency_Mask:
 393                         if ( IsTransparent(a) )
 394                         {
 395                             *ptrDst++ = rMask;
 396                             *ptrDst++ = bMask;
 397                             *ptrDst++ = gMask;
 398                             break;
 399                         }
 400                         // else: !transparent
 401
 402                         // must be opaque then as otherwise we shouldn't be
 403                         // using the mask at all
 404                         wxASSERT_MSG( IsOpaque(a), _T("logic error") );
 405
 406                         // fall through
 407
 408                     case Transparency_Alpha:
 409                         if ( alpha )
 410                             *alpha++ = a;
 411                         // fall through
 412
 413                     case Transparency_None:
 414                         *ptrDst++ = g;
 415                         *ptrDst++ = g;
 416                         *ptrDst++ = g;
 417                         break;
 418                 }
 419             }
 420         }
 421     }
 422     else // colour image: RGBRGB...
 423     {
 424         for ( png_uint_32 y = 0; y < height; y++ )
 425         {
 426             const unsigned char *ptrSrc = lines[y];
 427             for ( png_uint_32 x = 0; x < width; x++ )
 428             {
 429                 unsigned char r = *ptrSrc++;
 430                 unsigned char g = *ptrSrc++;
 431                 unsigned char b = *ptrSrc++;
 432                 unsigned char a = *ptrSrc++;
 433
 434                 // the logic here is the same as for the grey case except
 435                 // where noted
 436                 if ( !IsOpaque(a) && transparency == Transparency_None )
 437                 {
 438                     transparency = CheckTransparency
 439                                    (
 440                                         ptrSrc,
 441                                         x, y,
 442                                         width, height,
 443                                         3
 444                                    );
 445
 446                     if ( transparency == Transparency_Mask )
 447                     {
 448                         FindMaskColour(lines, width, height,
 449                                        rMask, gMask, bMask);
 450                     }
 451                     else // transparency == Transparency_Alpha
 452                     {
 453                         alpha = InitAlpha(image, x, y);
 454                     }
 455
 456                 }
 457
 458                 switch ( transparency )
 459                 {
 460                     case Transparency_Mask:
 461                         if ( IsTransparent(a) )
 462                         {
 463                             // if we couldn't find a unique colour for the mask, we
 464                             // can have real pixels with the same value as the mask
 465                             // and it's better to slightly change their colour than
 466                             // to make them transparent
 467                             if ( r == rMask && g == gMask && b == bMask )
 468                             {
 469                                 r++;
 470                             }
 471
 472                             *ptrDst++ = rMask;
 473                             *ptrDst++ = bMask;
 474                             *ptrDst++ = gMask;
 475                             break;
 476                         }
 477                         // else: !transparent
 478
 479                         // must be opaque then as otherwise we shouldn't be
 480                         // using the mask at all
 481                         wxASSERT_MSG( IsOpaque(a), _T("logic error") );
 482
 483                         // fall through
 484
 485                     case Transparency_Alpha:
 486                         if ( alpha )
 487                             *alpha++ = a;
 488                         // fall through
 489
 490                     case Transparency_None:
 491                         *ptrDst++ = r;
 492                         *ptrDst++ = g;
 493                         *ptrDst++ = b;
 494                         break;
 495                 }
 496             }
 497         }
 498     }
 499
 500     if ( transparency == Transparency_Mask )
 501     {
 502         image->SetMaskColour(rMask, gMask, bMask);
 503     }
 504 }
 505
 506 // temporarily disable the warning C4611 (interaction between '_setjmp' and
 507 // C++ object destruction is non-portable) - I don't see any dtors here
 508 #ifdef __VISUALC__
 509     #pragma warning(disable:4611)
 510 #endif /* VC++ */
 511
 512 bool
 513 wxPNGHandler::LoadFile(wxImage *image,
 514                        wxInputStream& stream,
 515                        bool verbose,
 516                        int WXUNUSED(index))
 517 {
 518     // VZ: as this function uses setjmp() the only fool proof error handling
 519     //     method is to use goto (setjmp is not really C++ dtors friendly...)
 520
 521     unsigned char **lines = NULL;
 522     png_infop info_ptr = (png_infop) NULL;
 523     wxPNGInfoStruct wxinfo;
 524
 525     wxinfo.verbose = verbose;
 526     wxinfo.stream.in = &stream;
 527
 528     image->Destroy();
 529
 530     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
 531         (voidp) NULL,
 532         (png_error_ptr) NULL,
 533         (png_error_ptr) NULL );
 534     if (!png_ptr)
 535         goto error;
 536
 537     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 538
 539     // NB: please see the comment near wxPNGInfoStruct declaration for
 540     //     explanation why this line is mandatory
 541     png_set_read_fn( png_ptr, &wxinfo, _PNG_stream_reader);
 542
 543     info_ptr = png_create_info_struct( png_ptr );
 544     if (!info_ptr)
 545         goto error;
 546
 547     if (setjmp(wxinfo.jmpbuf))
 548         goto error;
 549
 550     png_uint_32 i, width, height;
 551     int bit_depth, color_type, interlace_type;
 552
 553     png_read_info( png_ptr, info_ptr );
 554     png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
 555
 556     if (color_type == PNG_COLOR_TYPE_PALETTE)
 557         png_set_expand( png_ptr );
 558
 559     // Fix for Bug [ 439207 ] Monochrome PNG images come up black
 560     if (bit_depth < 8)
 561         png_set_expand( png_ptr );
 562
 563     png_set_strip_16( png_ptr );
 564     png_set_packing( png_ptr );
 565     if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
 566         png_set_expand( png_ptr );
 567     png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
 568
 569     image->Create( (int)width, (int)height );
 570
 571     if (!image->Ok())
 572         goto error;
 573
 574     lines = (unsigned char **)malloc( (size_t)(height * sizeof(unsigned char *)) );
 575     if ( !lines )
 576         goto error;
 577
 578     for (i = 0; i < height; i++)
 579     {
 580         if ((lines[i] = (unsigned char *)malloc( (size_t)(width * (sizeof(unsigned char) * 4)))) == NULL)
 581         {
 582             for ( unsigned int n = 0; n < i; n++ )
 583                 free( lines[n] );
 584             goto error;
 585         }
 586     }
 587
 588     png_read_image( png_ptr, lines );
 589     png_read_end( png_ptr, info_ptr );
 590     png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 591
 592     // loaded successfully, now init wxImage with this data
 593     CopyDataFromPNG(image, lines, width, height, color_type);
 594
 595     for ( i = 0; i < height; i++ )
 596         free( lines[i] );
 597     free( lines );
 598
 599     return TRUE;
 600
 601 error:
 602     if (verbose)
 603        wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
 604
 605     if ( image->Ok() )
 606     {
 607         image->Destroy();
 608     }
 609
 610     if ( lines )
 611     {
 612         free( lines );
 613     }
 614
 615     if ( png_ptr )
 616     {
 617         if ( info_ptr )
 618         {
 619             png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 620             free(info_ptr);
 621         }
 622         else
 623             png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
 624     }
 625     return FALSE;
 626 }
 627
 628 // ----------------------------------------------------------------------------
 629 // writing PNGs
 630 // ----------------------------------------------------------------------------
 631
 632 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 633 {
 634     wxPNGInfoStruct wxinfo;
 635
 636     wxinfo.verbose = verbose;
 637     wxinfo.stream.out = &stream;
 638
 639     png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 640     if (!png_ptr)
 641     {
 642         if (verbose)
 643            wxLogError(_("Couldn't save PNG image."));
 644         return FALSE;
 645     }
 646
 647     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 648
 649     png_infop info_ptr = png_create_info_struct(png_ptr);
 650     if (info_ptr == NULL)
 651     {
 652         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 653         if (verbose)
 654            wxLogError(_("Couldn't save PNG image."));
 655         return FALSE;
 656     }
 657
 658     if (setjmp(wxinfo.jmpbuf))
 659     {
 660         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 661         if (verbose)
 662            wxLogError(_("Couldn't save PNG image."));
 663         return FALSE;
 664     }
 665
 666     // NB: please see the comment near wxPNGInfoStruct declaration for
 667     //     explanation why this line is mandatory
 668     png_set_write_fn( png_ptr, &wxinfo, _PNG_stream_writer, NULL);
 669
 670     png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
 671         PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
 672         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 673
 674     png_color_8 sig_bit;
 675     sig_bit.red = 8;
 676     sig_bit.green = 8;
 677     sig_bit.blue = 8;
 678     sig_bit.alpha = 8;
 679     png_set_sBIT( png_ptr, info_ptr, &sig_bit );
 680     png_write_info( png_ptr, info_ptr );
 681     png_set_shift( png_ptr, &sig_bit );
 682     png_set_packing( png_ptr );
 683
 684     unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
 685     if (!data)
 686     {
 687         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 688         return FALSE;
 689     }
 690
 691     for (int y = 0; y < image->GetHeight(); y++)
 692     {
 693         unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
 694         for (int x = 0; x < image->GetWidth(); x++)
 695         {
 696             data[(x << 2) + 0] = *ptr++;
 697             data[(x << 2) + 1] = *ptr++;
 698             data[(x << 2) + 2] = *ptr++;
 699             if (( !image->HasMask() ) || \
 700                 (data[(x << 2) + 0] != image->GetMaskRed()) || \
 701                 (data[(x << 2) + 1] != image->GetMaskGreen()) || \
 702                 (data[(x << 2) + 2] != image->GetMaskBlue()))
 703             {
 704                 data[(x << 2) + 3] = 255;
 705             }
 706             else
 707             {
 708                 data[(x << 2) + 3] = 0;
 709             }
 710         }
 711         png_bytep row_ptr = data;
 712         png_write_rows( png_ptr, &row_ptr, 1 );
 713     }
 714
 715     free(data);
 716     png_write_end( png_ptr, info_ptr );
 717     png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
 718
 719     return TRUE;
 720 }
 721
 722 #ifdef __VISUALC__
 723     #pragma warning(default:4611)
 724 #endif /* VC++ */
 725
 726 #endif  // wxUSE_STREAMS
 727
 728 #endif  // wxUSE_LIBPNG