src/common/imagpng.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #ifdef __GNUG__
  11 #pragma implementation "imagpng.h"
  12 #endif
  13
  14 // For compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #ifdef __BORLANDC__
  18   #pragma hdrstop
  19 #endif
  20
  21 #ifndef WX_PRECOMP
  22   #include "wx/defs.h"
  23 #endif
  24
  25 #if wxUSE_IMAGE && wxUSE_LIBPNG
  26
  27 #include "wx/imagpng.h"
  28 #include "wx/bitmap.h"
  29 #include "wx/debug.h"
  30 #include "wx/log.h"
  31 #include "wx/app.h"
  32 #include "png.h"
  33 #include "wx/filefn.h"
  34 #include "wx/wfstream.h"
  35 #include "wx/intl.h"
  36 #include "wx/module.h"
  37
  38 // For memcpy
  39 #include <string.h>
  40
  41 #ifdef __SALFORDC__
  42 #ifdef FAR
  43 #undef FAR
  44 #endif
  45 #endif
  46
  47 #ifdef __WXMSW__
  48 #include <windows.h>
  49 #endif
  50
  51 //-----------------------------------------------------------------------------
  52 // wxPNGHandler
  53 //-----------------------------------------------------------------------------
  54
  55 IMPLEMENT_DYNAMIC_CLASS(wxPNGHandler,wxImageHandler)
  56
  57 #if wxUSE_LIBPNG
  58
  59 #ifndef PNGLINKAGEMODE
  60   #define PNGLINKAGEMODE LINKAGEMODE
  61 #endif
  62
  63
  64 // VS: wxPNGInfoStruct declared below is a hack that needs some explanation.
  65 //     First, let me describe what's the problem: libpng uses jmp_buf in
  66 //     its png_struct structure. Unfortunately, this structure is
  67 //     compiler-specific and may vary in size, so if you use libpng compiled
  68 //     as DLL with another compiler than the main executable, it may not work
  69 //     (this is for example the case with wxMGL port and SciTech MGL library
  70 //     that provides custom runtime-loadable libpng implementation with jmpbuf
  71 //     disabled altogether). Luckily, it is still possible to use setjmp() &
  72 //     longjmp() as long as the structure is not part of png_struct.
  73 //
  74 //     Sadly, there's no clean way to attach user-defined data to png_struct.
  75 //     There is only one customizable place, png_struct.io_ptr, which is meant
  76 //     only for I/O routines and is set with png_set_read_fn or
  77 //     png_set_write_fn. The hacky part is that we use io_ptr to store
  78 //     a pointer to wxPNGInfoStruct that holds I/O structures _and_ jmp_buf.
  79
  80 struct wxPNGInfoStruct
  81 {
  82     jmp_buf jmpbuf;
  83     bool verbose;
  84
  85     union
  86     {
  87         wxInputStream  *in;
  88         wxOutputStream *out;
  89     } stream;
  90 };
  91
  92 #define WX_PNG_INFO(png_ptr) ((wxPNGInfoStruct*)png_get_io_ptr(png_ptr))
  93
  94
  95 extern "C"
  96 {
  97
  98 void PNGLINKAGEMODE _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
  99 {
 100     WX_PNG_INFO(png_ptr)->stream.in->Read(data, length);
 101 }
 102
 103 void PNGLINKAGEMODE _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
 104 {
 105     WX_PNG_INFO(png_ptr)->stream.out->Write(data, length);
 106 }
 107
 108 // from pngerror.c
 109 // so that the libpng doesn't send anything on stderr
 110 void
 111 PNGLINKAGEMODE wx_png_error(png_structp png_ptr, png_const_charp message)
 112 {
 113     wxPNGInfoStruct *info = WX_PNG_INFO(png_ptr);
 114     if (info->verbose)
 115         wxLogError( wxString::FromAscii(message) );
 116
 117 #ifdef USE_FAR_KEYWORD
 118     {
 119        jmp_buf jmpbuf;
 120        png_memcpy(jmpbuf,info->jmpbuf,sizeof(jmp_buf));
 121        longjmp(jmpbuf, 1);
 122     }
 123 #else
 124     longjmp(info->jmpbuf, 1);
 125 #endif
 126 }
 127
 128 void
 129 PNGLINKAGEMODE wx_png_warning(png_structp png_ptr, png_const_charp message)
 130 {
 131     wxPNGInfoStruct *info = WX_PNG_INFO(png_ptr);
 132     if (info->verbose)
 133         wxLogWarning( wxString::FromAscii(message) );
 134 }
 135
 136 } // extern "C"
 137
 138 // temporarily disable the warning C4611 (interaction between '_setjmp' and
 139 // C++ object destruction is non-portable) - I don't see any dtors here
 140 #ifdef __VISUALC__
 141     #pragma warning(disable:4611)
 142 #endif /* VC++ */
 143
 144 bool wxPNGHandler::LoadFile( wxImage *image, wxInputStream& stream, bool verbose, int WXUNUSED(index) )
 145 {
 146     // VZ: as this function uses setjmp() the only fool proof error handling
 147     //     method is to use goto (setjmp is not really C++ dtors friendly...)
 148
 149     unsigned char **lines;
 150     unsigned int i;
 151     png_infop info_ptr = (png_infop) NULL;
 152     wxPNGInfoStruct wxinfo;
 153
 154     wxinfo.verbose = verbose;
 155     wxinfo.stream.in = &stream;
 156
 157     image->Destroy();
 158
 159     png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING,
 160         (voidp) NULL,
 161         (png_error_ptr) NULL,
 162         (png_error_ptr) NULL );
 163     if (!png_ptr)
 164         goto error_nolines;
 165
 166     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 167
 168     // NB: please see the comment near wxPNGInfoStruct declaration for
 169     //     explanation why this line is mandatory
 170     png_set_read_fn( png_ptr, &wxinfo, _PNG_stream_reader);
 171
 172     info_ptr = png_create_info_struct( png_ptr );
 173     if (!info_ptr)
 174         goto error_nolines;
 175
 176     if (setjmp(wxinfo.jmpbuf))
 177         goto error_nolines;
 178
 179     if (info_ptr->color_type == PNG_COLOR_TYPE_RGB_ALPHA)
 180         goto error_nolines;
 181
 182     png_uint_32 width,height;
 183     int bit_depth,color_type,interlace_type;
 184
 185     png_read_info( png_ptr, info_ptr );
 186     png_get_IHDR( png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, (int*) NULL, (int*) NULL );
 187
 188     if (color_type == PNG_COLOR_TYPE_PALETTE)
 189         png_set_expand( png_ptr );
 190
 191     // Fix for Bug [ 439207 ] Monochrome PNG images come up black
 192     if (bit_depth < 8)
 193         png_set_expand( png_ptr );
 194
 195     png_set_strip_16( png_ptr );
 196     png_set_packing( png_ptr );
 197     if (png_get_valid( png_ptr, info_ptr, PNG_INFO_tRNS))
 198         png_set_expand( png_ptr );
 199     png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
 200
 201     image->Create( (int)width, (int)height );
 202
 203     if (!image->Ok())
 204         goto error_nolines;
 205
 206     lines = (unsigned char **)malloc( (size_t)(height * sizeof(unsigned char *)) );
 207     if (lines == NULL)
 208         goto error_nolines;
 209
 210     for (i = 0; i < height; i++)
 211     {
 212         if ((lines[i] = (unsigned char *)malloc( (size_t)(width * (sizeof(unsigned char) * 4)))) == NULL)
 213         {
 214             for ( unsigned int n = 0; n < i; n++ )
 215                 free( lines[n] );
 216             goto error;
 217         }
 218     }
 219
 220     // loaded successfully!
 221     {
 222         int transp = 0;
 223         png_read_image( png_ptr, lines );
 224         png_read_end( png_ptr, info_ptr );
 225         png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 226         unsigned char *ptr = image->GetData();
 227         if ((color_type == PNG_COLOR_TYPE_GRAY) ||
 228             (color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
 229         {
 230             for (unsigned int y = 0; y < height; y++)
 231             {
 232                 unsigned char *ptr2 = lines[y];
 233                 for (unsigned int x = 0; x < width; x++)
 234                 {
 235                     unsigned char r = *ptr2++;
 236                     unsigned char a = *ptr2++;
 237                     if (a < 128)
 238                     {
 239                         *ptr++ = 255;
 240                         *ptr++ = 0;
 241                         *ptr++ = 255;
 242                         transp = 1;
 243                     }
 244                     else
 245                     {
 246                         *ptr++ = r;
 247                         *ptr++ = r;
 248                         *ptr++ = r;
 249                     }
 250                 }
 251             }
 252         }
 253         else
 254         {
 255             for (unsigned int y = 0; y < height; y++)
 256             {
 257                 unsigned char *ptr2 = lines[y];
 258                 for (unsigned int x = 0; x < width; x++)
 259                 {
 260                     unsigned char r = *ptr2++;
 261                     unsigned char g = *ptr2++;
 262                     unsigned char b = *ptr2++;
 263                     unsigned char a = *ptr2++;
 264                     if (a < 128)
 265                     {
 266                         *ptr++ = 255;
 267                         *ptr++ = 0;
 268                         *ptr++ = 255;
 269                         transp = 1;
 270                     }
 271                     else
 272                     {
 273                         if ((r == 255) && (g == 0) && (b == 255)) r = 254;
 274                         *ptr++ = r;
 275                         *ptr++ = g;
 276                         *ptr++ = b;
 277                     }
 278                 }
 279             }
 280         }
 281
 282         for ( unsigned int j = 0; j < height; j++ )
 283             free( lines[j] );
 284         free( lines );
 285
 286         if (transp)
 287         {
 288             image->SetMaskColour( 255, 0, 255 );
 289         }
 290         else
 291         {
 292             image->SetMask( FALSE );
 293         }
 294     }
 295
 296     return TRUE;
 297
 298  error_nolines:
 299     lines = NULL; // called from before it was set
 300  error:
 301     if (verbose)
 302        wxLogError(_("Couldn't load a PNG image - file is corrupted or not enough memory."));
 303
 304     if ( image->Ok() )
 305     {
 306         image->Destroy();
 307     }
 308
 309     if ( lines )
 310     {
 311         free( lines );
 312     }
 313
 314     if ( png_ptr )
 315     {
 316         if ( info_ptr )
 317         {
 318             png_destroy_read_struct( &png_ptr, &info_ptr, (png_infopp) NULL );
 319             free(info_ptr);
 320         }
 321         else
 322             png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
 323     }
 324     return FALSE;
 325 }
 326
 327 bool wxPNGHandler::SaveFile( wxImage *image, wxOutputStream& stream, bool verbose )
 328 {
 329     wxPNGInfoStruct wxinfo;
 330
 331     wxinfo.verbose = verbose;
 332     wxinfo.stream.out = &stream;
 333
 334     png_structp png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 335     if (!png_ptr)
 336     {
 337         if (verbose)
 338            wxLogError(_("Couldn't save PNG image."));
 339         return FALSE;
 340     }
 341
 342     png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
 343
 344     png_infop info_ptr = png_create_info_struct(png_ptr);
 345     if (info_ptr == NULL)
 346     {
 347         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 348         if (verbose)
 349            wxLogError(_("Couldn't save PNG image."));
 350         return FALSE;
 351     }
 352
 353     if (setjmp(wxinfo.jmpbuf))
 354     {
 355         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 356         if (verbose)
 357            wxLogError(_("Couldn't save PNG image."));
 358         return FALSE;
 359     }
 360
 361     // NB: please see the comment near wxPNGInfoStruct declaration for
 362     //     explanation why this line is mandatory
 363     png_set_write_fn( png_ptr, &wxinfo, _PNG_stream_writer, NULL);
 364
 365     png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
 366         PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
 367         PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 368
 369     png_color_8 sig_bit;
 370     sig_bit.red = 8;
 371     sig_bit.green = 8;
 372     sig_bit.blue = 8;
 373     sig_bit.alpha = 8;
 374     png_set_sBIT( png_ptr, info_ptr, &sig_bit );
 375     png_write_info( png_ptr, info_ptr );
 376     png_set_shift( png_ptr, &sig_bit );
 377     png_set_packing( png_ptr );
 378
 379     unsigned char *data = (unsigned char *)malloc( image->GetWidth()*4 );
 380     if (!data)
 381     {
 382         png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
 383         return FALSE;
 384     }
 385
 386     for (int y = 0; y < image->GetHeight(); y++)
 387     {
 388         unsigned char *ptr = image->GetData() + (y * image->GetWidth() * 3);
 389         for (int x = 0; x < image->GetWidth(); x++)
 390         {
 391             data[(x << 2) + 0] = *ptr++;
 392             data[(x << 2) + 1] = *ptr++;
 393             data[(x << 2) + 2] = *ptr++;
 394             if (( !image->HasMask() ) || \
 395                 (data[(x << 2) + 0] != image->GetMaskRed()) || \
 396                 (data[(x << 2) + 1] != image->GetMaskGreen()) || \
 397                 (data[(x << 2) + 2] != image->GetMaskBlue()))
 398             {
 399                 data[(x << 2) + 3] = 255;
 400             }
 401             else
 402             {
 403                 data[(x << 2) + 3] = 0;
 404             }
 405         }
 406         png_bytep row_ptr = data;
 407         png_write_rows( png_ptr, &row_ptr, 1 );
 408     }
 409
 410     free(data);
 411     png_write_end( png_ptr, info_ptr );
 412     png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
 413
 414     return TRUE;
 415 }
 416
 417 #ifdef __VISUALC__
 418     #pragma warning(default:4611)
 419 #endif /* VC++ */
 420
 421 bool wxPNGHandler::DoCanRead( wxInputStream& stream )
 422 {
 423     unsigned char hdr[4];
 424
 425     if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
 426         return FALSE;
 427
 428     return memcmp(hdr, "\211PNG", WXSIZEOF(hdr)) == 0;
 429 }
 430
 431 #endif  // wxUSE_STREAMS
 432
 433 #endif  // wxUSE_LIBPNG