// declarations
// ============================================================================
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "imagpng.h"
#endif
// return the kind of transparency needed for this image assuming that it does
// have transparent pixels, i.e. either Transparency_Alpha or Transparency_Mask
static Transparency
-CheckTransparency(const unsigned char *ptr,
- png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h);
+CheckTransparency(unsigned char **lines,
+ png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
+ size_t numColBytes);
// init the alpha channel for the image and fill it with 1s up to (x, y)
static unsigned char *InitAlpha(wxImage *image, png_uint_32 x, png_uint_32 y);
FindMaskColour(unsigned char **lines, png_uint_32 width, png_uint_32 height,
unsigned char& rMask, unsigned char& gMask, unsigned char& bMask);
+// is the pixel with this value of alpha a fully opaque one?
+static inline
+bool IsOpaque(unsigned char a)
+{
+ return a == 0xff;
+}
+
+// is the pixel with this value of alpha a fully transparent one?
+static inline
+bool IsTransparent(unsigned char a)
+{
+ return !a;
+}
+
// ============================================================================
// wxPNGHandler implementation
// ============================================================================
extern "C"
{
-void PNGLINKAGEMODE _PNG_stream_reader( png_structp png_ptr, png_bytep data, png_size_t length )
+void PNGLINKAGEMODE wx_PNG_stream_reader( png_structp png_ptr, png_bytep data,
+ png_size_t length )
{
WX_PNG_INFO(png_ptr)->stream.in->Read(data, length);
}
-void PNGLINKAGEMODE _PNG_stream_writer( png_structp png_ptr, png_bytep data, png_size_t length )
+void PNGLINKAGEMODE wx_PNG_stream_writer( png_structp png_ptr, png_bytep data,
+ png_size_t length )
{
WX_PNG_INFO(png_ptr)->stream.out->Write(data, length);
}
// ----------------------------------------------------------------------------
// determine the kind of transparency we need for this image: if the only alpha
-// values it has are 0 and 0xff then we can simply create a mask for it, we
-// should be ok with a simple mask but otherwise we need a full blown alpha
-// channel in wxImage
+// values it has are 0 (transparent) and 0xff (opaque) then we can simply
+// create a mask for it, we should be ok with a simple mask but otherwise we
+// need a full blown alpha channel in wxImage
//
// parameters:
-// ptr the start of the data to examine
+// lines raw PNG data
// x, y starting position
// w, h size of the image
// numColBytes number of colour bytes (1 for grey scale, 3 for RGB)
// (NB: alpha always follows the colour bytes)
Transparency
-CheckTransparency(const unsigned char *ptr,
+CheckTransparency(unsigned char **lines,
png_uint_32 x, png_uint_32 y, png_uint_32 w, png_uint_32 h,
size_t numColBytes)
{
// suppose that a mask will suffice and check all the remaining alpha
// values to see if it does
- unsigned char a2;
- unsigned const char *ptr2 = ptr;
- for ( png_uint_32 y2 = y; y2 < h; y2++ )
+ for ( ; y < h; y++ )
{
- for ( png_uint_32 x2 = x + 1; x2 < w; x2++ )
+ // each pixel is numColBytes+1 bytes, offset into the current line by
+ // the current x position
+ unsigned const char *ptr = lines[y] + (x * (numColBytes + 1));
+
+ for ( png_uint_32 x2 = x; x2 < w; x2++ )
{
- // skip the grey byte
- ptr2 += numColBytes;
- a2 = *ptr2++;
+ // skip the grey or colour byte(s)
+ ptr += numColBytes;
+
+ unsigned char a2 = *ptr++;
- if ( a2 && a2 != 0xff )
+ if ( !IsTransparent(a2) && !IsOpaque(a2) )
{
// not fully opaque nor fully transparent, hence need alpha
return Transparency_Alpha;
}
}
+
+ // during the next loop iteration check all the pixels in the row
+ x = 0;
}
// mask will be enough
unsigned char *alpha = image->GetAlpha();
// set alpha for the pixels we had so far
- for ( png_uint_32 y2 = 0; y2 <= y; y2++ )
+ png_uint_32 end = y * image->GetWidth() + x;
+ for ( png_uint_32 i = 0; i < end; i++ )
{
- for ( png_uint_32 x2 = 0; x2 < x; x2++ )
- {
- // all the previous pixels were opaque
- *alpha++ = 0xff;
- }
+ // all the previous pixels were opaque
+ *alpha++ = 0xff;
}
return alpha;
unsigned char hdr[4];
if ( !stream.Read(hdr, WXSIZEOF(hdr)) )
- return FALSE;
+ return false;
return memcmp(hdr, "\211PNG", WXSIZEOF(hdr)) == 0;
}
// the first time we encounter a transparent pixel we must
// decide about what to do about them
- if ( a != 0xff && transparency == Transparency_None )
+ if ( !IsOpaque(a) && transparency == Transparency_None )
{
// we'll need at least the mask for this image and
// maybe even full alpha channel info: the former is
// only, otherwisewe need the latter
transparency = CheckTransparency
(
- ptrSrc,
+ lines,
x, y,
width, height,
1
switch ( transparency )
{
+ case Transparency_Mask:
+ if ( IsTransparent(a) )
+ {
+ *ptrDst++ = rMask;
+ *ptrDst++ = bMask;
+ *ptrDst++ = gMask;
+ break;
+ }
+ // else: !transparent
+
+ // must be opaque then as otherwise we shouldn't be
+ // using the mask at all
+ wxASSERT_MSG( IsOpaque(a), _T("logic error") );
+
+ // fall through
+
case Transparency_Alpha:
- *alpha++ = a;
+ if ( alpha )
+ *alpha++ = a;
// fall through
case Transparency_None:
*ptrDst++ = g;
*ptrDst++ = g;
break;
-
- case Transparency_Mask:
- *ptrDst++ = rMask;
- *ptrDst++ = bMask;
- *ptrDst++ = gMask;
}
}
}
// the logic here is the same as for the grey case except
// where noted
- if ( a != 0xff && transparency == Transparency_None )
+ if ( !IsOpaque(a) && transparency == Transparency_None )
{
transparency = CheckTransparency
(
- ptrSrc,
+ lines,
x, y,
width, height,
3
switch ( transparency )
{
+ case Transparency_Mask:
+ if ( IsTransparent(a) )
+ {
+ *ptrDst++ = rMask;
+ *ptrDst++ = bMask;
+ *ptrDst++ = gMask;
+ break;
+ }
+ else // !transparent
+ {
+ // must be opaque then as otherwise we shouldn't be
+ // using the mask at all
+ wxASSERT_MSG( IsOpaque(a), _T("logic error") );
+
+ // if we couldn't find a unique colour for the
+ // mask, we can have real pixels with the same
+ // value as the mask and it's better to slightly
+ // change their colour than to make them
+ // transparent
+ if ( r == rMask && g == gMask && b == bMask )
+ {
+ r++;
+ }
+ }
+
+ // fall through
+
case Transparency_Alpha:
- *alpha++ = a;
+ if ( alpha )
+ *alpha++ = a;
// fall through
case Transparency_None:
*ptrDst++ = g;
*ptrDst++ = b;
break;
-
- case Transparency_Mask:
- // if we couldn't find a unique colour for the mask, we
- // can have real pixels with the same value as the mask
- // and it's better to slightly change their colour than
- // to make them transparent
- if ( r == rMask && g == gMask && b == bMask )
- {
- r++;
- }
-
- *ptrDst++ = rMask;
- *ptrDst++ = bMask;
- *ptrDst++ = gMask;
}
}
}
// NB: please see the comment near wxPNGInfoStruct declaration for
// explanation why this line is mandatory
- png_set_read_fn( png_ptr, &wxinfo, _PNG_stream_reader);
+ png_set_read_fn( png_ptr, &wxinfo, wx_PNG_stream_reader);
info_ptr = png_create_info_struct( png_ptr );
if (!info_ptr)
png_set_expand( png_ptr );
png_set_filler( png_ptr, 0xff, PNG_FILLER_AFTER );
- image->Create( (int)width, (int)height );
+ image->Create((int)width, (int)height, false /* no need to init pixels */);
if (!image->Ok())
goto error;
free( lines[i] );
free( lines );
- return TRUE;
+ return true;
error:
if (verbose)
else
png_destroy_read_struct( &png_ptr, (png_infopp) NULL, (png_infopp) NULL );
}
- return FALSE;
+ return false;
}
// ----------------------------------------------------------------------------
{
if (verbose)
wxLogError(_("Couldn't save PNG image."));
- return FALSE;
+ return false;
}
png_set_error_fn(png_ptr, (png_voidp)NULL, wx_png_error, wx_png_warning);
png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
if (verbose)
wxLogError(_("Couldn't save PNG image."));
- return FALSE;
+ return false;
}
if (setjmp(wxinfo.jmpbuf))
png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
if (verbose)
wxLogError(_("Couldn't save PNG image."));
- return FALSE;
+ return false;
}
// NB: please see the comment near wxPNGInfoStruct declaration for
// explanation why this line is mandatory
- png_set_write_fn( png_ptr, &wxinfo, _PNG_stream_writer, NULL);
+ png_set_write_fn( png_ptr, &wxinfo, wx_PNG_stream_writer, NULL);
png_set_IHDR( png_ptr, info_ptr, image->GetWidth(), image->GetHeight(), 8,
PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
if (!data)
{
png_destroy_write_struct( &png_ptr, (png_infopp)NULL );
- return FALSE;
+ return false;
}
for (int y = 0; y < image->GetHeight(); y++)
data[(x << 2) + 0] = *ptr++;
data[(x << 2) + 1] = *ptr++;
data[(x << 2) + 2] = *ptr++;
- if (( !image->HasMask() ) || \
+ if ( image->HasAlpha() )
+ {
+ data[(x << 2) + 3] = image->GetAlpha(x, y);
+ }
+ else if (( !image->HasMask() ) || \
(data[(x << 2) + 0] != image->GetMaskRed()) || \
(data[(x << 2) + 1] != image->GetMaskGreen()) || \
(data[(x << 2) + 2] != image->GetMaskBlue()))
png_write_end( png_ptr, info_ptr );
png_destroy_write_struct( &png_ptr, (png_infopp)&info_ptr );
- return TRUE;
+ return true;
}
#ifdef __VISUALC__
projects / wxWidgets.git / blobdiff