vcl/source/gdi/pngread.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: pngread.cxx,v $
  10  * $Revision: 1.28.78.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_vcl.hxx"
  33
  34 #include <vcl/pngread.hxx>
  35
  36 #include <cmath>
  37 #include <rtl/crc.h>
  38 #include <rtl/memory.h>
  39 #include <rtl/alloc.h>
  40 #include <tools/zcodec.hxx>
  41 #include <tools/stream.hxx>
  42 #include <vcl/bmpacc.hxx>
  43 #include <vcl/svapp.hxx>
  44 #include <vcl/alpha.hxx>
  45 #include <osl/endian.h>
  46
  47 // -----------
  48 // - Defines -
  49 // -----------
  50
  51 #define PNGCHUNK_IHDR           0x49484452
  52 #define PNGCHUNK_PLTE           0x504c5445
  53 #define PNGCHUNK_IDAT           0x49444154
  54 #define PNGCHUNK_IEND           0x49454e44
  55 #define PNGCHUNK_bKGD           0x624b4744
  56 #define PNGCHUNK_cHRM           0x6348524d
  57 #define PNGCHUNK_gAMA           0x67414d41
  58 #define PNGCHUNK_hIST           0x68495354
  59 #define PNGCHUNK_pHYs           0x70485973
  60 #define PNGCHUNK_sBIT           0x73425420
  61 #define PNGCHUNK_tIME           0x74494d45
  62 #define PNGCHUNK_tEXt           0x74455874
  63 #define PNGCHUNK_tRNS           0x74524e53
  64 #define PNGCHUNK_zTXt           0x7a545874
  65 #define PMGCHUNG_msOG           0x6d734f47              // Microsoft Office Animated GIF
  66
  67 #define VIEWING_GAMMA           2.35
  68 #define DISPLAY_GAMMA           1.0
  69
  70 namespace vcl
  71 {
  72 // -----------
  73 // - statics -
  74 // -----------
  75
  76 // ------------------------------------------------------------------------------
  77
  78 static const BYTE mpDefaultColorTable[ 256 ] =
  79 {       0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  80     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  81     0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  82     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  83     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
  84     0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  85     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  86     0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
  87     0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  88     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  89     0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
  90     0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  91     0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
  92     0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  93     0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  94     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
  95 };
  96
  97 // -------------
  98 // - PNGReaderImpl -
  99 // -------------
 100
 101 class PNGReaderImpl
 102 {
 103 private:
 104     SvStream&           mrPNGStream;
 105     sal_uInt16          mnOrigStreamMode;
 106
 107     std::vector< vcl::PNGReader::ChunkData >    maChunkSeq;
 108     std::vector< vcl::PNGReader::ChunkData >::iterator maChunkIter;
 109     std::vector< sal_uInt8 >::iterator          maDataIter;
 110
 111     Bitmap*                             mpBmp;
 112     BitmapWriteAccess*  mpAcc;
 113     Bitmap*                             mpMaskBmp;
 114     AlphaMask*                  mpAlphaMask;
 115     BitmapWriteAccess*  mpMaskAcc;
 116     ZCodec*                     mpZCodec;
 117     BYTE*                               mpInflateInBuf; // as big as the size of a scanline + alphachannel + 1
 118     BYTE*                               mpScanPrior;    // pointer to the latest scanline
 119     BYTE*                               mpTransTab;             // for transparency in images with palette colortype
 120     BYTE*                               mpScanCurrent;  // pointer into the current scanline
 121     BYTE*                               mpColorTable;   //
 122     sal_Size            mnStreamSize;   // estimate of PNG file size
 123     sal_uInt32          mnChunkType;    // Type of current PNG chunk
 124     sal_Int32           mnChunkLen;     // Length of current PNG chunk
 125     Size                maOrigSize;     // pixel size of the full image
 126     Size                maTargetSize;   // pixel size of the result image
 127     Size                maPhysSize;     // prefered size in MAP_100TH_MM units
 128     sal_uInt32          mnBPP;          // number of bytes per pixel
 129     sal_uInt32          mnScansize;     // max size of scanline
 130     sal_uInt32          mnYpos;         // latest y position in full image
 131     int                 mnPass;         // if interlaced the latest pass ( 1..7 ) else 7
 132     sal_uInt32          mnXStart;       // the starting X for the current pass
 133     sal_uInt32          mnXAdd;         // the increment for input images X coords for the current pass
 134     sal_uInt32          mnYAdd;         // the increment for input images Y coords for the current pass
 135     int                 mnPreviewShift; // shift to convert orig image coords into preview image coords
 136     int                 mnPreviewMask;  // == ((1 << mnPreviewShift) - 1)
 137     USHORT                              mnIStmOldMode;
 138     USHORT                              mnTargetDepth;          // pixel depth of target bitmap
 139     BYTE                                mnTransRed;
 140     BYTE                                mnTransGreen;
 141     BYTE                                mnTransBlue;
 142     BYTE                                mnPngDepth;             // pixel depth of PNG data
 143     BYTE                                mnColorType;
 144     BYTE                                mnCompressionType;
 145     BYTE                                mnFilterType;
 146     BYTE                                mnInterlaceType;
 147     BitmapColor                 mcTranspColor;  // transparency mask's transparency "color"
 148     BitmapColor                 mcOpaqueColor;  // transparency mask's opaque "color"
 149     BOOL                                mbTransparent;  // graphic includes an tRNS Chunk or an alpha Channel
 150     BOOL                                mbAlphaChannel; // is true for ColorType 4 and 6
 151     BOOL                                mbRGBTriple;
 152     BOOL                                mbPalette;              // FALSE if we need a Palette
 153     BOOL                                mbGrayScale;
 154     BOOL                                mbzCodecInUse;
 155     BOOL                                mbStatus;
 156     BOOL                                mbIDAT;                 // TRUE if finished with enough IDAT chunks
 157     BOOL                                mbGamma;                // TRUE if Gamma Correction available
 158     BOOL                                mbpHYs;                 // TRUE if pysical size of pixel available
 159     sal_Bool                    mbIgnoreGammaChunk;
 160
 161     bool                ReadNextChunk();
 162     void                ReadRemainingChunks();
 163     void                SkipRemainingChunks();
 164
 165     void                ImplSetPixel( sal_uInt32 y, sal_uInt32 x, const BitmapColor & );
 166     void                ImplSetPixel( sal_uInt32 y, sal_uInt32 x, BYTE nPalIndex );
 167     void                ImplSetTranspPixel( sal_uInt32 y, sal_uInt32 x, const BitmapColor &, BOOL bTrans );
 168     void                ImplSetAlphaPixel( sal_uInt32 y, sal_uInt32 x, BYTE nPalIndex, BYTE nAlpha );
 169     void                                ImplSetAlphaPixel( sal_uInt32 y, sal_uInt32 x, const BitmapColor&, BYTE nAlpha );
 170     void                                ImplReadIDAT();
 171     bool                ImplPreparePass();
 172     void                ImplApplyFilter();
 173     void                ImplDrawScanline( sal_uInt32 nXStart, sal_uInt32 nXAdd );
 174     BOOL                                ImplReadTransparent();
 175     void                                ImplGetGamma();
 176     void                                ImplGetBackground();
 177     BYTE                                ImplScaleColor();
 178     BOOL                                ImplReadHeader( const Size& rPreviewSizeHint );
 179     BOOL                                ImplReadPalette();
 180     void                                ImplGetGrayPalette( sal_uInt16 );
 181     sal_uInt32                  ImplReadsal_uInt32();
 182
 183 public:
 184
 185                         PNGReaderImpl( SvStream& );
 186                         ~PNGReaderImpl();
 187
 188     BitmapEx            GetBitmapEx( const Size& rPreviewSizeHint );
 189     const std::vector< PNGReader::ChunkData >& GetAllChunks();
 190     void                                SetIgnoreGammaChunk( sal_Bool bIgnore ){ mbIgnoreGammaChunk = bIgnore; };
 191 };
 192
 193 // ------------------------------------------------------------------------------
 194
 195 PNGReaderImpl::PNGReaderImpl( SvStream& rPNGStream )
 196 :   mrPNGStream( rPNGStream ),
 197     mpBmp                       ( NULL ),
 198     mpAcc                       ( NULL ),
 199     mpMaskBmp           ( NULL ),
 200     mpAlphaMask         ( NULL ),
 201     mpMaskAcc           ( NULL ),
 202     mpZCodec            ( new ZCodec( DEFAULT_IN_BUFSIZE, DEFAULT_OUT_BUFSIZE, MAX_MEM_USAGE ) ),
 203     mpInflateInBuf      ( NULL ),
 204     mpScanPrior         ( NULL ),
 205     mpTransTab          ( NULL ),
 206     mpColorTable        ( (sal_uInt8*) mpDefaultColorTable ),
 207     mbzCodecInUse       ( sal_False ),
 208     mbStatus( TRUE),
 209     mbIDAT( FALSE ),
 210     mbGamma                             ( sal_False ),
 211     mbpHYs                              ( sal_False ),
 212     mbIgnoreGammaChunk  ( sal_False )
 213 {
 214     // prepare the PNG data stream
 215     mnOrigStreamMode = mrPNGStream.GetNumberFormatInt();
 216     mrPNGStream.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
 217
 218     // prepare the chunk reader
 219     maChunkSeq.reserve( 16 );
 220     maChunkIter = maChunkSeq.begin();
 221
 222     // estimate PNG file size (to allow sanity checks)
 223     const sal_Size nStreamPos = mrPNGStream.Tell();
 224     mrPNGStream.Seek( STREAM_SEEK_TO_END );
 225     mnStreamSize = mrPNGStream.Tell();
 226     mrPNGStream.Seek( nStreamPos );
 227
 228     // check the PNG header magic
 229     sal_uInt32 nDummy = 0;
 230     mrPNGStream >> nDummy;
 231     mbStatus = (nDummy == 0x89504e47);
 232     mrPNGStream >> nDummy;
 233     mbStatus &= (nDummy == 0x0d0a1a0a);
 234
 235     mnPreviewShift = 0;
 236     mnPreviewMask = (1 << mnPreviewShift) - 1;
 237 }
 238
 239 // ------------------------------------------------------------------------
 240
 241 PNGReaderImpl::~PNGReaderImpl()
 242 {
 243     mrPNGStream.SetNumberFormatInt( mnOrigStreamMode );
 244
 245     if ( mbzCodecInUse )
 246         mpZCodec->EndCompression();
 247
 248     if( mpColorTable != mpDefaultColorTable )
 249         delete[] mpColorTable;
 250
 251     delete mpBmp;
 252     delete mpAlphaMask;
 253     delete mpMaskBmp;
 254     delete[] mpTransTab;
 255     delete[] mpInflateInBuf;
 256     delete[] mpScanPrior;
 257     delete mpZCodec;
 258 }
 259
 260 // ------------------------------------------------------------------------
 261
 262 bool PNGReaderImpl::ReadNextChunk()
 263 {
 264     if( maChunkIter == maChunkSeq.end() )
 265     {
 266         // get the next chunk from the stream
 267
 268         // unless we are at the end of the PNG stream
 269         if( mrPNGStream.IsEof() || (mrPNGStream.GetError() != ERRCODE_NONE) )
 270             return false;
 271         if( !maChunkSeq.empty() && (maChunkSeq.back().nType == PNGCHUNK_IEND) )
 272             return false;
 273
 274         PNGReader::ChunkData aDummyChunk;
 275         maChunkIter = maChunkSeq.insert( maChunkSeq.end(), aDummyChunk );
 276         PNGReader::ChunkData& rChunkData = *maChunkIter;
 277
 278         // read the chunk header
 279         mrPNGStream >> mnChunkLen >> mnChunkType;
 280         rChunkData.nType = mnChunkType;
 281
 282         // #128377#/#149343# sanity check for chunk length
 283         if( mnChunkLen < 0 )
 284             return false;
 285         const sal_Size nStreamPos = mrPNGStream.Tell();
 286         if( nStreamPos + mnChunkLen >= mnStreamSize )
 287             return false;
 288
 289         // calculate chunktype CRC (swap it back to original byte order)
 290         sal_uInt32 nChunkType = mnChunkType;;
 291         #if defined(__LITTLEENDIAN) || defined(OSL_LITENDIAN)
 292         nChunkType = SWAPLONG( nChunkType );
 293         #endif
 294         sal_uInt32 nCRC32 = rtl_crc32( 0, &nChunkType, 4 );
 295
 296         // read the chunk data and check the CRC
 297         if( mnChunkLen && !mrPNGStream.IsEof() )
 298         {
 299             rChunkData.aData.resize( mnChunkLen );
 300
 301             sal_Int32 nBytesRead = 0;
 302             do {
 303                 sal_uInt8* pPtr = &rChunkData.aData[ nBytesRead ];
 304                 nBytesRead += mrPNGStream.Read( pPtr, mnChunkLen - nBytesRead );
 305             } while ( ( nBytesRead < mnChunkLen ) && ( mrPNGStream.GetError() == ERRCODE_NONE ) );
 306
 307             nCRC32 = rtl_crc32( nCRC32, &rChunkData.aData[ 0 ], mnChunkLen );
 308             maDataIter = rChunkData.aData.begin();
 309         }
 310         sal_uInt32 nCheck;
 311         mrPNGStream >> nCheck;
 312         if( nCRC32 != nCheck )
 313             return false;
 314     }
 315     else
 316     {
 317         // the next chunk was already read
 318         mnChunkType = (*maChunkIter).nType;
 319         mnChunkLen = (*maChunkIter).aData.size();
 320         maDataIter = (*maChunkIter).aData.begin();
 321     }
 322
 323     ++maChunkIter;
 324     if( mnChunkType == PNGCHUNK_IEND )
 325         return false;
 326     return true;
 327 }
 328
 329 // ------------------------------------------------------------------------
 330
 331 // read the remaining chunks from mrPNGStream
 332 void PNGReaderImpl::ReadRemainingChunks()
 333 {
 334     while( ReadNextChunk() ) ;
 335 }
 336
 337 // ------------------------------------------------------------------------
 338
 339 // move position of mrPNGStream to the end of the file
 340 void PNGReaderImpl::SkipRemainingChunks()
 341 {
 342     // nothing to skip if the last chunk was read
 343     if( !maChunkSeq.empty() && (maChunkSeq.back().nType == PNGCHUNK_IEND) )
 344         return;
 345
 346     // read from the stream until the IEND chunk is found
 347     const sal_Size nStreamPos = mrPNGStream.Tell();
 348     while( !mrPNGStream.IsEof() && (mrPNGStream.GetError() == ERRCODE_NONE) )
 349     {
 350         mrPNGStream >> mnChunkLen >> mnChunkType;
 351         if( mnChunkLen < 0 )
 352             break;
 353         if( nStreamPos + mnChunkLen >= mnStreamSize )
 354             break;
 355         mrPNGStream.SeekRel( mnChunkLen + 4 );  // skip data + CRC
 356         if( mnChunkType == PNGCHUNK_IEND )
 357             break;
 358     }
 359 }
 360
 361 // ------------------------------------------------------------------------
 362
 363 const std::vector< vcl::PNGReader::ChunkData >& PNGReaderImpl::GetAllChunks()
 364 {
 365     ReadRemainingChunks();
 366     return maChunkSeq;
 367 }
 368
 369 // ------------------------------------------------------------------------
 370
 371 BitmapEx PNGReaderImpl::GetBitmapEx( const Size& rPreviewSizeHint )
 372 {
 373     // reset to the first chunk
 374     maChunkIter = maChunkSeq.begin();
 375
 376     // parse the chunks
 377     while( mbStatus && !mbIDAT && ReadNextChunk() )
 378     {
 379         switch( mnChunkType )
 380         {
 381             case PNGCHUNK_IHDR :
 382             {
 383                 mbStatus = ImplReadHeader( rPreviewSizeHint );
 384             }
 385             break;
 386
 387             case PNGCHUNK_gAMA :                                                                // the gamma chunk must precede
 388             {                                                                                                   // the 'IDAT' and also the 'PLTE'(if available )
 389                 if ( !mbIgnoreGammaChunk && ( mbIDAT == FALSE ) )
 390                     ImplGetGamma();
 391             }
 392             break;
 393
 394             case PNGCHUNK_PLTE :
 395             {
 396                 if ( !mbPalette )
 397                     mbStatus = ImplReadPalette();
 398             }
 399             break;
 400
 401             case PNGCHUNK_tRNS :
 402             {
 403                 if ( !mbIDAT )                                                                  // the tRNS chunk must precede the IDAT
 404                     mbStatus = ImplReadTransparent();
 405             }
 406             break;
 407
 408             case PNGCHUNK_bKGD :                                                                // the background chunk must appear
 409             {
 410                 if ( ( mbIDAT == FALSE ) && mbPalette )                 // before the 'IDAT' and after the
 411                     ImplGetBackground();                                                // PLTE(if available ) chunk.
 412             }
 413             break;
 414
 415             case PNGCHUNK_IDAT :
 416             {
 417                 if ( !mbIDAT )          // the gfx is finished, but there may be left a zlibCRC of about 4Bytes
 418                     ImplReadIDAT();
 419             }
 420             break;
 421
 422             case PNGCHUNK_pHYs :
 423             {
 424                 if ( !mbIDAT && mnChunkLen == 9 )
 425                 {
 426                     sal_uInt32 nXPixelPerMeter = ImplReadsal_uInt32();
 427                     sal_uInt32 nYPixelPerMeter = ImplReadsal_uInt32();
 428
 429                     sal_uInt8 nUnitSpecifier = *maDataIter++;
 430                     if( (nUnitSpecifier == 1) && nXPixelPerMeter && nXPixelPerMeter )
 431                     {
 432                         mbpHYs = sal_True;
 433
 434                         // convert into MAP_100TH_MM
 435                         maPhysSize.Width()  = (sal_Int32)( (100000.0 * maOrigSize.Width()) / nXPixelPerMeter );
 436                         maPhysSize.Height() = (sal_Int32)( (100000.0 * maOrigSize.Height()) / nYPixelPerMeter );
 437                     }
 438                 }
 439             }
 440             break;
 441
 442             case PNGCHUNK_IEND:
 443                 mbStatus = mbIDAT;  // there is a problem if the image is not complete yet
 444             break;
 445         }
 446     }
 447
 448     // release write access of the bitmaps
 449     if ( mpAcc )
 450         mpBmp->ReleaseAccess( mpAcc ), mpAcc = NULL;
 451
 452     if ( mpMaskAcc )
 453     {
 454         if ( mpAlphaMask )
 455             mpAlphaMask->ReleaseAccess( mpMaskAcc );
 456         else if ( mpMaskBmp )
 457             mpMaskBmp->ReleaseAccess( mpMaskAcc );
 458
 459         mpMaskAcc = NULL;
 460     }
 461
 462     // return the resulting BitmapEx
 463     BitmapEx aRet;
 464
 465     if( !mbStatus || !mbIDAT )
 466         aRet.Clear();
 467     else
 468     {
 469         if ( mpAlphaMask )
 470             aRet = BitmapEx( *mpBmp, *mpAlphaMask );
 471         else if ( mpMaskBmp )
 472             aRet = BitmapEx( *mpBmp, *mpMaskBmp );
 473         else
 474             aRet = *mpBmp;
 475
 476         if ( mbpHYs && maPhysSize.Width() && maPhysSize.Height() )
 477         {
 478             aRet.SetPrefMapMode( MAP_100TH_MM );
 479             aRet.SetPrefSize( maPhysSize );
 480         }
 481
 482 #if 0
 483         // TODO: make sure nobody depends on the stream being after the IEND chunks
 484         // => let them do ReadChunks before
 485         ReadRemainingChunks();
 486 #endif
 487     }
 488
 489     return aRet;
 490 }
 491
 492 // ------------------------------------------------------------------------
 493
 494 BOOL PNGReaderImpl::ImplReadHeader( const Size& rPreviewSizeHint )
 495 {
 496     if( mnChunkLen < 13 )
 497         return FALSE;
 498
 499     maOrigSize.Width()  = ImplReadsal_uInt32();
 500     maOrigSize.Height() = ImplReadsal_uInt32();
 501
 502     if ( !maOrigSize.Width() || !maOrigSize.Height() )
 503         return FALSE;
 504
 505     mnPngDepth = *(maDataIter++);
 506     mnColorType = *(maDataIter++);
 507
 508     mnCompressionType = *(maDataIter++);
 509     if( mnCompressionType != 0 )    // unknown compression type
 510         return FALSE;
 511
 512     mnFilterType = *(maDataIter++);
 513     if( mnFilterType != 0 )         // unknown filter type
 514         return FALSE;
 515
 516     mnInterlaceType = *(maDataIter++);
 517     switch ( mnInterlaceType ) // filter type valid ?
 518     {
 519         case 0 :  // progressive image
 520             mnPass = 7;
 521             break;
 522         case 1 :  // Adam7-interlaced image
 523             mnPass = 0;
 524             break;
 525         default:
 526             return FALSE;
 527     }
 528
 529     mbPalette = TRUE;
 530     mbIDAT = mbAlphaChannel = mbTransparent = FALSE;
 531     mbGrayScale = mbRGBTriple = FALSE;
 532     mnTargetDepth = mnPngDepth;
 533     mnScansize = ( ( maOrigSize.Width() * mnPngDepth ) + 7 ) >> 3;
 534
 535     // valid color types are 0,2,3,4 & 6
 536     switch ( mnColorType )
 537     {
 538         case 0 :        // each pixel is a grayscale
 539         {
 540             switch ( mnPngDepth )
 541             {
 542                 case 2 : // 2bit target not available -> use four bits
 543                     mnTargetDepth = 4;  // we have to expand the bitmap
 544                     mbGrayScale = TRUE;
 545                     break;
 546                 case 16 :
 547                     mnTargetDepth = 8;  // we have to reduce the bitmap
 548                     // fall through
 549                 case 1 :
 550                 case 4 :
 551                 case 8 :
 552                     mbGrayScale = TRUE;
 553                     break;
 554                 default :
 555                     return FALSE;
 556             }
 557         }
 558         break;
 559
 560         case 2 :        // each pixel is an RGB triple
 561         {
 562             mbRGBTriple = TRUE;
 563             mnScansize *= 3;
 564             switch ( mnPngDepth )
 565             {
 566                 case 16 :                       // we have to reduce the bitmap
 567                 case 8 :
 568                     mnTargetDepth = 24;
 569                     break;
 570                 default :
 571                     return FALSE;
 572             }
 573         }
 574         break;
 575
 576         case 3 :        // each pixel is a palette index
 577         {
 578             switch ( mnPngDepth )
 579             {
 580                 case 2 :
 581                     mnTargetDepth = 4;  // we have to expand the bitmap
 582                     // fall through
 583                 case 1 :
 584                 case 4 :
 585                 case 8 :
 586                     mbPalette = FALSE;
 587                     break;
 588                 default :
 589                     return FALSE;
 590             }
 591         }
 592         break;
 593
 594         case 4 :        // each pixel is a grayscale sample followed by an alpha sample
 595         {
 596             mnScansize *= 2;
 597             mbAlphaChannel = TRUE;
 598             switch ( mnPngDepth )
 599             {
 600                 case 16 :
 601                     mnTargetDepth = 8;  // we have to reduce the bitmap
 602                 case 8 :
 603                     mbGrayScale = TRUE;
 604                     break;
 605                 default :
 606                     return FALSE;
 607             }
 608         }
 609         break;
 610
 611         case 6 :        // each pixel is an RGB triple followed by an alpha sample
 612         {
 613             mbRGBTriple = TRUE;
 614             mnScansize *= 4;
 615             mbAlphaChannel = TRUE;
 616             switch (mnPngDepth )
 617             {
 618                 case 16 :                       // we have to reduce the bitmap
 619                 case 8 :
 620                     mnTargetDepth = 24;
 621                     break;
 622                 default :
 623                     return FALSE;
 624             }
 625         }
 626         break;
 627
 628         default :
 629             return FALSE;
 630     }
 631
 632     mnBPP = mnScansize / maOrigSize.Width();
 633     if ( !mnBPP )
 634         mnBPP = 1;
 635
 636     mnScansize++;       // each scanline includes one filterbyte
 637
 638     // TODO: switch between both scanlines instead of copying
 639     mpInflateInBuf = new BYTE[ mnScansize ];
 640     mpScanCurrent = mpInflateInBuf;
 641     mpScanPrior = new BYTE[ mnScansize ];
 642
 643     // calculate target size from original size and the preview hint
 644     if( rPreviewSizeHint.Width() || rPreviewSizeHint.Height() )
 645     {
 646         Size aPreviewSize( rPreviewSizeHint.Width(), rPreviewSizeHint.Height() );
 647         maTargetSize = maOrigSize;
 648
 649         if( aPreviewSize.Width() == 0 ) {
 650             aPreviewSize.setWidth( ( maOrigSize.Width()*aPreviewSize.Height() )/maOrigSize.Height() );
 651             if( aPreviewSize.Width() <= 0 )
 652                 aPreviewSize.setWidth( 1 );
 653         } else if( aPreviewSize.Height() == 0 ) {
 654             aPreviewSize.setHeight( ( maOrigSize.Height()*aPreviewSize.Width() )/maOrigSize.Width() );
 655             if( aPreviewSize.Height() <= 0 )
 656                 aPreviewSize.setHeight( 1 );
 657         }
 658
 659         if( aPreviewSize.Width() < maOrigSize.Width() && aPreviewSize.Height() < maOrigSize.Height() ) {
 660             OSL_TRACE("preview size %dx%d", aPreviewSize.Width(), aPreviewSize.Height() );
 661
 662             for( int i = 1; i < 5; ++i )
 663                 {
 664                     if( (maTargetSize.Width() >> i) < aPreviewSize.Width() )
 665                         break;
 666                     if( (maTargetSize.Height() >> i) < aPreviewSize.Height() )
 667                         break;
 668                     mnPreviewShift = i;
 669                 }
 670             mnPreviewMask = (1 << mnPreviewShift) - 1;
 671         }
 672     }
 673
 674     maTargetSize.Width()  = (maOrigSize.Width() + mnPreviewMask) >> mnPreviewShift;
 675     maTargetSize.Height() = (maOrigSize.Height() + mnPreviewMask) >> mnPreviewShift;
 676
 677     mpBmp = new Bitmap( maTargetSize, mnTargetDepth );
 678     mpAcc = mpBmp->AcquireWriteAccess();
 679     if( !mpAcc )
 680         return FALSE;
 681
 682     mpBmp->SetSourceSizePixel( maOrigSize );
 683
 684     if ( mbAlphaChannel )
 685     {
 686         mpAlphaMask = new AlphaMask( maTargetSize );
 687         mpAlphaMask->Erase( 128 );
 688         mpMaskAcc = mpAlphaMask->AcquireWriteAccess();
 689         if( !mpMaskAcc )
 690             return FALSE;
 691     }
 692
 693     if ( mbGrayScale )
 694         ImplGetGrayPalette( mnPngDepth );
 695
 696     ImplPreparePass();
 697
 698     return TRUE;
 699 }
 700
 701 // ------------------------------------------------------------------------
 702
 703 void PNGReaderImpl::ImplGetGrayPalette( sal_uInt16 nBitDepth )
 704 {
 705     if( nBitDepth > 8 )
 706         nBitDepth = 8;
 707
 708     sal_uInt16  nPaletteEntryCount = 1 << nBitDepth;
 709     sal_uInt32  nAdd = 256 / (nPaletteEntryCount - 1);
 710
 711     // no bitdepth==2 available
 712     // but bitdepth==4 with two unused bits is close enough
 713     if( nBitDepth == 2 )
 714         nPaletteEntryCount = 16;
 715
 716     mpAcc->SetPaletteEntryCount( nPaletteEntryCount );
 717     for ( sal_uInt32 i = 0, nStart = 0; nStart < 256; i++, nStart += nAdd )
 718         mpAcc->SetPaletteColor( (USHORT)i, BitmapColor( mpColorTable[ nStart ],
 719             mpColorTable[ nStart ], mpColorTable[ nStart ] ) );
 720 }
 721
 722 // ------------------------------------------------------------------------
 723
 724 BOOL PNGReaderImpl::ImplReadPalette()
 725 {
 726     sal_uInt16 nCount = static_cast<sal_uInt16>( mnChunkLen / 3 );
 727
 728     if ( ( ( mnChunkLen % 3 ) == 0 ) && ( ( 0 < nCount ) && ( nCount <= 256 ) ) && mpAcc )
 729     {
 730         mbPalette = TRUE;
 731         mpAcc->SetPaletteEntryCount( (USHORT) nCount );
 732
 733         for ( sal_uInt16 i = 0; i < nCount; i++ )
 734         {
 735             BYTE nRed =   mpColorTable[ *maDataIter++ ];
 736             BYTE nGreen = mpColorTable[ *maDataIter++ ];
 737             BYTE nBlue =  mpColorTable[ *maDataIter++ ];
 738             mpAcc->SetPaletteColor( i, Color( nRed, nGreen, nBlue ) );
 739         }
 740     }
 741     else
 742         mbStatus = FALSE;
 743
 744     return mbStatus;
 745 }
 746
 747 // ------------------------------------------------------------------------
 748
 749 BOOL PNGReaderImpl::ImplReadTransparent()
 750 {
 751     bool bNeedAlpha = false;
 752
 753     if ( mpTransTab == NULL )
 754     {
 755         switch ( mnColorType )
 756         {
 757             case 0 :
 758             {
 759                 if ( mnChunkLen == 2 )
 760                 {
 761                     mpTransTab = new sal_uInt8[ 256 ];
 762                     rtl_fillMemory( mpTransTab, 256, 0xff );
 763                     // color type 0 and 4 is always greyscale,
 764                     // so the return value can be used as index
 765                     sal_uInt8 nIndex = ImplScaleColor();
 766                     mpTransTab[ nIndex ] = 0;
 767                     mbTransparent = true;
 768                 }
 769             }
 770             break;
 771
 772             case 2 :
 773             {
 774                 if ( mnChunkLen == 6 )
 775                 {
 776                     mnTransRed = ImplScaleColor();
 777                     mnTransGreen = ImplScaleColor();
 778                     mnTransBlue = ImplScaleColor();
 779                     mbTransparent = true;
 780                 }
 781             }
 782             break;
 783
 784             case 3 :
 785             {
 786                 if ( mnChunkLen <= 256 )
 787                 {
 788                     mpTransTab = new BYTE [ 256 ];
 789                     rtl_fillMemory( mpTransTab, 256, 0xff );
 790                     rtl_copyMemory( mpTransTab, &(*maDataIter), mnChunkLen );
 791                     maDataIter += mnChunkLen;
 792                     mbTransparent = true;
 793                     // need alpha transparency if not on/off masking
 794                     for( int i = 0; i < mnChunkLen; ++i )
 795                        bNeedAlpha |= (mpTransTab[i]!=0x00) && (mpTransTab[i]!=0xFF);
 796                 }
 797             }
 798             break;
 799         }
 800     }
 801
 802     if( mbTransparent && !mbAlphaChannel && !mpMaskBmp )
 803     {
 804         if( bNeedAlpha)
 805         {
 806             mpAlphaMask = new AlphaMask( maTargetSize );
 807             mpMaskAcc = mpAlphaMask->AcquireWriteAccess();
 808         }
 809         else
 810         {
 811             mpMaskBmp = new Bitmap( maTargetSize, 1 );
 812             mpMaskAcc = mpMaskBmp->AcquireWriteAccess();
 813         }
 814         mbTransparent = (mpMaskAcc != NULL);
 815         if( !mbTransparent )
 816             return FALSE;
 817         mcOpaqueColor = BitmapColor( 0x00 );
 818         mcTranspColor = BitmapColor( 0xFF );
 819         mpMaskAcc->Erase( 0x00 );
 820     }
 821
 822     return TRUE;
 823 }
 824
 825 // ------------------------------------------------------------------------
 826
 827 void PNGReaderImpl::ImplGetGamma()
 828 {
 829     if( mnChunkLen < 4 )
 830         return;
 831
 832     sal_uInt32  nGammaValue = ImplReadsal_uInt32();
 833     double              fGamma = ( ( VIEWING_GAMMA / DISPLAY_GAMMA ) * ( (double)nGammaValue / 100000 ) );
 834     double              fInvGamma = ( fGamma <= 0.0 || fGamma > 10.0 ) ? 1.0 : ( 1.0 / fGamma );
 835
 836     if ( fInvGamma != 1.0 )
 837     {
 838         mbGamma = TRUE;
 839
 840         if ( mpColorTable == mpDefaultColorTable )
 841             mpColorTable = new sal_uInt8[ 256 ];
 842
 843         for ( sal_Int32 i = 0; i < 256; i++ )
 844             mpColorTable[ i ] = (sal_uInt8)(pow((double)i/255.0, fInvGamma) * 255.0 + 0.5);
 845
 846         if ( mbGrayScale )
 847             ImplGetGrayPalette( mnPngDepth );
 848     }
 849 }
 850
 851 // ------------------------------------------------------------------------
 852
 853 void PNGReaderImpl::ImplGetBackground()
 854 {
 855     switch ( mnColorType )
 856     {
 857         case 3 :
 858         {
 859             if ( mnChunkLen == 1 )
 860             {
 861                 UINT16 nCol = *maDataIter++;
 862                 if ( nCol < mpAcc->GetPaletteEntryCount() )
 863                 {
 864                     mpAcc->Erase( mpAcc->GetPaletteColor( (BYTE)nCol ) );
 865                     break;
 866                 }
 867             }
 868         }
 869         break;
 870
 871         case 0 :
 872         case 4 :
 873         {
 874             if ( mnChunkLen == 2 )
 875             {
 876                 // the color type 0 and 4 is always greyscale,
 877                 // so the return value can be used as index
 878                 sal_uInt8 nIndex = ImplScaleColor();
 879                 mpAcc->Erase( mpAcc->GetPaletteColor( nIndex ) );
 880             }
 881         }
 882         break;
 883
 884         case 2 :
 885         case 6 :
 886         {
 887             if ( mnChunkLen == 6 )
 888             {
 889                 sal_uInt8 nRed = ImplScaleColor();
 890                 sal_uInt8 nGreen = ImplScaleColor();
 891                 sal_uInt8 nBlue = ImplScaleColor();
 892                 mpAcc->Erase( Color( nRed, nGreen, nBlue ) );
 893             }
 894         }
 895         break;
 896     }
 897 }
 898
 899 // ------------------------------------------------------------------------
 900
 901 // for color type 0 and 4 (greyscale) the return value is always index to the color
 902 //                2 and 6 (RGB)       the return value is always the 8 bit color component
 903 sal_uInt8 PNGReaderImpl::ImplScaleColor()
 904 {
 905     sal_uInt32 nMask = ( ( 1 << mnPngDepth ) - 1 );
 906     sal_uInt16 nCol = ( *maDataIter++ << 8 );
 907
 908     nCol += *maDataIter++ & (sal_uInt16)nMask;
 909
 910     if ( mnPngDepth > 8 )       // convert 16bit graphics to 8
 911         nCol >>= 8;
 912
 913     return (sal_uInt8) nCol;
 914 }
 915
 916 // ------------------------------------------------------------------------
 917 // ImplReadIDAT reads as much image data as needed
 918
 919 void PNGReaderImpl::ImplReadIDAT()
 920 {
 921     if( mnChunkLen > 0 )
 922     {
 923         if ( mbzCodecInUse == FALSE )
 924         {
 925             mbzCodecInUse = TRUE;
 926             mpZCodec->BeginCompression( ZCODEC_PNG_DEFAULT );
 927         }
 928         mpZCodec->SetBreak( mnChunkLen );
 929         SvMemoryStream aIStrm( &(*maDataIter), mnChunkLen, STREAM_READ );
 930
 931         while ( ( mpZCodec->GetBreak() ) )
 932         {
 933             // get bytes needed to fill the current scanline
 934             sal_Int32 nToRead = mnScansize - (mpScanCurrent - mpInflateInBuf);
 935             sal_Int32 nRead = mpZCodec->ReadAsynchron( aIStrm, mpScanCurrent, nToRead );
 936             if ( nRead < 0 )
 937             {
 938                 mbStatus = FALSE;
 939                 break;
 940             }
 941             if ( nRead < nToRead )
 942             {
 943                 mpScanCurrent += nRead; // more ZStream data in the next IDAT chunk
 944                 break;
 945             }
 946             else  // this scanline is Finished
 947             {
 948                 mpScanCurrent = mpInflateInBuf;
 949                 ImplApplyFilter();
 950
 951                 ImplDrawScanline( mnXStart, mnXAdd );
 952                 mnYpos += mnYAdd;
 953             }
 954
 955             if ( mnYpos >= (sal_uInt32)maOrigSize.Height() )
 956             {
 957                 if( (mnPass < 7) && mnInterlaceType )
 958                     if( ImplPreparePass() )
 959                         continue;
 960                 mbIDAT = true;
 961                 break;
 962             }
 963         }
 964     }
 965
 966     if( mbIDAT )
 967     {
 968         mpZCodec->EndCompression();
 969         mbzCodecInUse = FALSE;
 970     }
 971 }
 972
 973 // ---------------------------------------------------------------------------------------------------
 974
 975 bool PNGReaderImpl::ImplPreparePass()
 976 {
 977     struct InterlaceParams{ int mnXStart, mnYStart, mnXAdd, mnYAdd; };
 978     static const InterlaceParams aInterlaceParams[8] =
 979     {
 980         // non-interlaced
 981         { 0, 0, 1, 1 },
 982         // Adam7-interlaced
 983         { 0, 0, 8, 8 },    // pass 1
 984         { 4, 0, 8, 8 },    // pass 2
 985         { 0, 4, 4, 8 },    // pass 3
 986         { 2, 0, 4, 4 },    // pass 4
 987         { 0, 2, 2, 4 },    // pass 5
 988         { 1, 0, 2, 2 },    // pass 6
 989         { 0, 1, 1, 2 }     // pass 7
 990     };
 991
 992     const InterlaceParams* pParam = &aInterlaceParams[ 0 ];
 993     if( mnInterlaceType )
 994     {
 995         while( ++mnPass <= 7 )
 996         {
 997             pParam = &aInterlaceParams[ mnPass ];
 998
 999             // skip this pass if the original image is too small for it
1000             if( (pParam->mnXStart < maOrigSize.Width())
1001             &&  (pParam->mnYStart < maOrigSize.Height()) )
1002                 break;
1003         }
1004         if( mnPass > 7 )
1005             return false;
1006
1007         // skip the last passes if possible (for scaled down target images)
1008         if( mnPreviewMask & (pParam->mnXStart | pParam->mnYStart) )
1009             return false;
1010     }
1011
1012     mnYpos      = pParam->mnYStart;
1013     mnXStart    = pParam->mnXStart;
1014     mnXAdd      = pParam->mnXAdd;
1015     mnYAdd      = pParam->mnYAdd;
1016
1017     // in Interlace mode the size of scanline is not constant
1018     // so first we calculate the number of entrys
1019     long nScanWidth = (maOrigSize.Width() - mnXStart + mnXAdd - 1) / mnXAdd;
1020     mnScansize = nScanWidth;
1021
1022     if( mbRGBTriple )
1023         mnScansize = 3 * nScanWidth;
1024
1025     if( mbAlphaChannel )
1026         mnScansize += nScanWidth;
1027
1028     // convert to width in bytes
1029     mnScansize = ( mnScansize*mnPngDepth + 7 ) >> 3;
1030
1031     ++mnScansize; // scan size also needs room for the filtertype byte
1032     rtl_zeroMemory( mpScanPrior, mnScansize );
1033
1034     return true;
1035 }
1036
1037 // ----------------------------------------------------------------------------
1038 // ImplApplyFilter writes the complete Scanline (nY)
1039 // in interlace mode the parameter nXStart and nXAdd are non-zero
1040
1041 void PNGReaderImpl::ImplApplyFilter()
1042 {
1043     OSL_ASSERT( mnScansize >= mnBPP + 1 );
1044     const BYTE* const pScanEnd = mpInflateInBuf + mnScansize;
1045
1046     BYTE nFilterType = *mpInflateInBuf; // the filter type may change each scanline
1047     switch ( nFilterType )
1048     {
1049         default: // unknown Scanline Filter Type
1050         case 0: // Filter Type "None"
1051             // we let the pixels pass and display the data unfiltered
1052             break;
1053
1054         case 1: // Scanline Filter Type "Sub"
1055         {
1056             BYTE* p1 = mpInflateInBuf + 1;
1057             const BYTE* p2 = p1;
1058             p1 += mnBPP;
1059
1060             // use left pixels
1061             do
1062                 *p1 = static_cast<BYTE>( *p1 + *(p2++) );
1063             while( ++p1 < pScanEnd );
1064         }
1065         break;
1066
1067         case 2: // Scanline Filter Type "Up"
1068         {
1069             BYTE* p1 = mpInflateInBuf + 1;
1070             const BYTE* p2 = mpScanPrior + 1;
1071
1072             // use pixels from prior line
1073             while( p1 < pScanEnd )
1074             {
1075                 *p1 = static_cast<BYTE>( *p1 + *(p2++) );
1076                 ++p1;
1077             }
1078         }
1079         break;
1080
1081         case 3: // Scanline Filter Type "Average"
1082         {
1083             BYTE* p1 = mpInflateInBuf + 1;
1084             const BYTE* p2 = mpScanPrior + 1;
1085             const BYTE* p3 = p1;
1086
1087             // use one pixel from prior line
1088             for( int n = mnBPP; --n >= 0; ++p1, ++p2)
1089                 *p1 = static_cast<BYTE>( *p1 + (*p2 >> 1) );
1090
1091             // predict by averaging the left and prior line pixels
1092             while( p1 < pScanEnd )
1093             {
1094                 *p1 = static_cast<BYTE>( *p1 + ((*(p2++) + *(p3++)) >> 1) );
1095                 ++p1;
1096             }
1097         }
1098         break;
1099
1100         case 4: // Scanline Filter Type "PaethPredictor"
1101         {
1102             BYTE* p1 = mpInflateInBuf + 1;
1103             const BYTE* p2 = mpScanPrior + 1;
1104             const BYTE* p3 = p1;
1105             const BYTE* p4 = p2;
1106
1107             // use one pixel from prior line
1108             for( int n = mnBPP; --n >= 0; ++p1)
1109                 *p1 = static_cast<BYTE>( *p1 + *(p2++) );
1110
1111             // predict by using the left and the prior line pixels
1112             while( p1 < pScanEnd )
1113             {
1114                 int na = *(p2++);
1115                 int nb = *(p3++);
1116                 int nc = *(p4++);
1117
1118                 int npa = nb - (int)nc;
1119                 int npb = na - (int)nc;
1120                 int npc = npa + npb;
1121
1122                 if( npa < 0 )
1123                     npa =-npa;
1124                 if( npb < 0 )
1125                     npb =-npb;
1126                 if( npc < 0 )
1127                     npc =-npc;
1128
1129                 if( npa > npb )
1130                     na = nb, npa = npb;
1131                 if( npa > npc )
1132                     na = nc;
1133
1134                 *p1 = static_cast<BYTE>( *p1 + na );
1135                 ++p1;
1136             }
1137         }
1138         break;
1139     }
1140
1141     rtl_copyMemory( mpScanPrior, mpInflateInBuf, mnScansize );
1142 }
1143
1144 // ---------------------------------------------------------------------------------------------------
1145 // ImplDrawScanlines draws the complete Scanline (nY) into the target bitmap
1146 // In interlace mode the parameter nXStart and nXAdd append to the currently used pass
1147
1148 void PNGReaderImpl::ImplDrawScanline( sal_uInt32 nXStart, sal_uInt32 nXAdd )
1149 {
1150     // optimization for downscaling
1151     if( mnYpos & mnPreviewMask )
1152         return;
1153     if( nXStart & mnPreviewMask )
1154         return;
1155
1156     // convert nY to pixel units in the target image
1157     // => TODO; also do this for nX here instead of in the ImplSet*Pixel() methods
1158     const sal_uInt32 nY = mnYpos >> mnPreviewShift;
1159
1160     const BYTE* pTmp = mpInflateInBuf + 1;
1161     if ( mpAcc->HasPalette() ) // alphachannel is not allowed by pictures including palette entries
1162     {
1163         switch ( mpAcc->GetBitCount() )
1164         {
1165             case 1 :
1166             {
1167                 if ( mbTransparent )
1168                 {
1169                     for ( sal_Int32 nX = nXStart, nShift = 0; nX < maOrigSize.Width(); nX += nXAdd )
1170                     {
1171                         BYTE nCol;
1172                         nShift = (nShift - 1) & 7;
1173                         if ( nShift == 0 )
1174                             nCol = *(pTmp++);
1175                         else
1176                             nCol = static_cast<BYTE>( *pTmp >> nShift );
1177                         nCol &= 1;
1178
1179                         ImplSetAlphaPixel( nY, nX, nCol, mpTransTab[ nCol ] );
1180                     }
1181                 }
1182                 else
1183                 {   // BMP_FORMAT_1BIT_MSB_PAL
1184                     for ( sal_Int32 nX = nXStart, nShift = 0; nX < maOrigSize.Width(); nX += nXAdd )
1185                     {
1186                         nShift = (nShift - 1) & 7;
1187
1188                         BYTE nCol;
1189                         if ( nShift == 0 )
1190                             nCol = *(pTmp++);
1191                         else
1192                             nCol = static_cast<BYTE>( *pTmp >> nShift );
1193                         nCol &= 1;
1194
1195                         ImplSetPixel( nY, nX, nCol );
1196                     }
1197                 }
1198             }
1199             break;
1200
1201             case 4 :
1202             {
1203                 if ( mbTransparent )
1204                 {
1205                     if ( mnPngDepth == 4 )      // check if source has a two bit pixel format
1206                     {
1207                         for ( sal_Int32 nX = nXStart, nXIndex = 0; nX < maOrigSize.Width(); nX += nXAdd, ++nXIndex )
1208                         {
1209                             if( nXIndex & 1 )
1210                             {
1211                                 ImplSetAlphaPixel( nY, nX, *pTmp & 0x0f, mpTransTab[ *pTmp & 0x0f ] );
1212                                 pTmp++;
1213                             }
1214                             else
1215                             {
1216                                 ImplSetAlphaPixel( nY, nX, ( *pTmp >> 4 ) & 0x0f, mpTransTab[ *pTmp >> 4 ] );
1217                             }
1218                         }
1219                     }
1220                     else // if ( mnPngDepth == 2 )
1221                     {
1222                         for ( sal_Int32 nX = nXStart, nXIndex = 0; nX < maOrigSize.Width(); nX += nXAdd, nXIndex++ )
1223                         {
1224                             BYTE nCol;
1225                             switch( nXIndex & 3 )
1226                             {
1227                                 case 0 :
1228                                     nCol = *pTmp >> 6;
1229                                 break;
1230
1231                                 case 1 :
1232                                     nCol = ( *pTmp >> 4 ) & 0x03 ;
1233                                 break;
1234
1235                                 case 2 :
1236                                     nCol = ( *pTmp >> 2 ) & 0x03;
1237                                 break;
1238
1239                                 case 3 :
1240                                     nCol = ( *pTmp++ ) & 0x03;
1241                                 break;
1242
1243                                 default:    // get rid of nCol uninitialized warning
1244                                     nCol = 0;
1245                                     break;
1246                             }
1247
1248                             ImplSetAlphaPixel( nY, nX, nCol, mpTransTab[ nCol ] );
1249                         }
1250                     }
1251                 }
1252                 else
1253                 {
1254                     if ( mnPngDepth == 4 )      // maybe the source is a two bitmap graphic
1255                     {   // BMP_FORMAT_4BIT_LSN_PAL
1256                         for ( sal_Int32 nX = nXStart, nXIndex = 0; nX < maOrigSize.Width(); nX += nXAdd, nXIndex++ )
1257                         {
1258                             if( nXIndex & 1 )
1259                                 ImplSetPixel( nY, nX, *pTmp++ & 0x0f );
1260                             else
1261                                 ImplSetPixel( nY, nX, ( *pTmp >> 4 ) & 0x0f );
1262                         }
1263                     }
1264                     else // if ( mnPngDepth == 2 )
1265                     {
1266                         for ( sal_Int32 nX = nXStart, nXIndex = 0; nX < maOrigSize.Width(); nX += nXAdd, nXIndex++ )
1267                         {
1268                             switch( nXIndex & 3 )
1269                             {
1270                                 case 0 :
1271                                     ImplSetPixel( nY, nX, *pTmp >> 6 );
1272                                 break;
1273
1274                                 case 1 :
1275                                     ImplSetPixel( nY, nX, ( *pTmp >> 4 ) & 0x03 );
1276                                 break;
1277
1278                                 case 2 :
1279                                     ImplSetPixel( nY, nX, ( *pTmp >> 2 ) & 0x03 );
1280                                 break;
1281
1282                                 case 3 :
1283                                     ImplSetPixel( nY, nX, *pTmp++ & 0x03 );
1284                                 break;
1285                             }
1286                         }
1287                     }
1288                 }
1289             }
1290             break;
1291
1292             case 8 :
1293             {
1294                 if ( mbAlphaChannel )
1295                 {
1296                     if ( mnPngDepth == 8 )      // maybe the source is a 16 bit grayscale
1297                     {
1298                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 2 )
1299                             ImplSetAlphaPixel( nY, nX, pTmp[ 0 ], pTmp[ 1 ] );
1300                     }
1301                     else
1302                     {
1303                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 4 )
1304                             ImplSetAlphaPixel( nY, nX, pTmp[ 0 ], pTmp[ 2 ] );
1305                     }
1306                 }
1307                 else if ( mbTransparent )
1308                 {
1309                     if ( mnPngDepth == 8 )      // maybe the source is a 16 bit grayscale
1310                     {
1311                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp++ )
1312                             ImplSetAlphaPixel( nY, nX, *pTmp, mpTransTab[ *pTmp ] );
1313                     }
1314                     else
1315                     {
1316                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 2 )
1317                             ImplSetAlphaPixel( nY, nX, *pTmp, mpTransTab[ *pTmp ] );
1318                     }
1319                 }
1320                 else // neither alpha nor transparency
1321                 {
1322                     if ( mnPngDepth == 8 )      // maybe the source is a 16 bit grayscale
1323                     {
1324                         if( nXAdd == 1 && mnPreviewShift == 0 )  // copy raw line data if possible
1325                         {
1326                             int nLineBytes = maOrigSize.Width();
1327                             mpAcc->CopyScanline( nY, pTmp, BMP_FORMAT_8BIT_PAL, nLineBytes );
1328                             pTmp += nLineBytes;
1329                         }
1330                         else
1331                         {
1332                             for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd )
1333                                 ImplSetPixel( nY, nX, *pTmp++ );
1334                         }
1335                     }
1336                     else
1337                     {
1338                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 2 )
1339                             ImplSetPixel( nY, nX, *pTmp );
1340                     }
1341                 }
1342             }
1343             break;
1344
1345             default :
1346                 mbStatus = FALSE;
1347             break;
1348         }
1349     }
1350     else // no palette => truecolor
1351     {
1352         if( mbAlphaChannel ) // has RGB + alpha
1353         {   // BMP_FORMAT_32BIT_TC_RGBA
1354             if ( mnPngDepth == 8 )  // maybe the source has 16 bit per sample
1355             {
1356                 if ( mpColorTable != mpDefaultColorTable )
1357                 {
1358                     for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 4 )
1359                        ImplSetAlphaPixel( nY, nX, BitmapColor( mpColorTable[ pTmp[ 0 ] ],
1360                                                                mpColorTable[ pTmp[ 1 ] ],
1361                                                                mpColorTable[ pTmp[ 2 ] ] ), pTmp[ 3 ] );
1362                 }
1363                 else
1364                 {
1365 //                  if ( nXAdd == 1 && mnPreviewShift == 0 ) // copy raw line data if possible
1366 //                  {
1367 //                      int nLineBytes = 4 * maOrigSize.Width();
1368 //                      mpAcc->CopyScanline( nY, pTmp, BMP_FORMAT_32BIT_TC_RGBA, nLineBytes );
1369 //                      pTmp += nLineBytes;
1370 //                  }
1371 //                  else
1372                     {
1373                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 4 )
1374                             ImplSetAlphaPixel( nY, nX, BitmapColor( pTmp[0], pTmp[1], pTmp[2] ), pTmp[3] );
1375                     }
1376                 }
1377             }
1378             else
1379             {   // BMP_FORMAT_64BIT_TC_RGBA
1380                 for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 8 )
1381                     ImplSetAlphaPixel( nY, nX, BitmapColor( mpColorTable[ pTmp[ 0 ] ],
1382                                                         mpColorTable[ pTmp[ 2 ] ],
1383                                                         mpColorTable[ pTmp[ 4 ] ] ), pTmp[6] );
1384             }
1385         }
1386         else if( mbTransparent ) // has RGB + transparency
1387         {   // BMP_FORMAT_24BIT_TC_RGB
1388             if ( mnPngDepth == 8 )  // maybe the source has 16 bit per sample
1389             {
1390                 for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 3 )
1391                 {
1392                     sal_uInt8 nRed = pTmp[ 0 ];
1393                     sal_uInt8 nGreen = pTmp[ 1 ];
1394                     sal_uInt8 nBlue = pTmp[ 2 ];
1395                     sal_Bool bTransparent = ( ( nRed == mnTransRed )
1396                                          && ( nGreen == mnTransGreen )
1397                                         && ( nBlue == mnTransBlue ) );
1398
1399                     ImplSetTranspPixel( nY, nX, BitmapColor( mpColorTable[ nRed ],
1400                                                         mpColorTable[ nGreen ],
1401                                                         mpColorTable[ nBlue ] ), bTransparent );
1402                 }
1403             }
1404             else
1405             {   // BMP_FORMAT_48BIT_TC_RGB
1406                 for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 6 )
1407                 {
1408                     sal_uInt8 nRed = pTmp[ 0 ];
1409                     sal_uInt8 nGreen = pTmp[ 2 ];
1410                     sal_uInt8 nBlue = pTmp[ 4 ];
1411                     sal_Bool bTransparent = ( ( nRed == mnTransRed )
1412                                         && ( nGreen == mnTransGreen )
1413                                         && ( nBlue == mnTransBlue ) );
1414
1415                     ImplSetTranspPixel( nY, nX, BitmapColor( mpColorTable[ nRed ],
1416                                                         mpColorTable[ nGreen ],
1417                                                         mpColorTable[ nBlue ] ), bTransparent );
1418                 }
1419             }
1420         }
1421         else  // has RGB but neither alpha nor transparency
1422         {   // BMP_FORMAT_24BIT_TC_RGB
1423             if ( mnPngDepth == 8 )   // maybe the source has 16 bit per sample
1424             {
1425                 if ( mpColorTable != mpDefaultColorTable )
1426                 {
1427                     for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 3 )
1428                         ImplSetPixel( nY, nX, BitmapColor( mpColorTable[ pTmp[ 0 ] ],
1429                                                             mpColorTable[ pTmp[ 1 ] ],
1430                                                             mpColorTable[ pTmp[ 2 ] ] ) );
1431                 }
1432                 else
1433                 {
1434                     if( nXAdd == 1 && mnPreviewShift == 0 ) // copy raw line data if possible
1435                     {
1436                         int nLineBytes = maOrigSize.Width() * 3;
1437                         mpAcc->CopyScanline( nY, pTmp, BMP_FORMAT_24BIT_TC_RGB, nLineBytes );
1438                         pTmp += nLineBytes;
1439                     }
1440                     else
1441                     {
1442                         for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 3 )
1443                             ImplSetPixel( nY, nX, BitmapColor( pTmp[0], pTmp[1], pTmp[2] ) );
1444                     }
1445                 }
1446             }
1447             else
1448             {   // BMP_FORMAT_48BIT_TC_RGB
1449                 for ( sal_Int32 nX = nXStart; nX < maOrigSize.Width(); nX += nXAdd, pTmp += 6 )
1450                     ImplSetPixel( nY, nX, BitmapColor( mpColorTable[ pTmp[ 0 ] ],
1451                                                         mpColorTable[ pTmp[ 2 ] ],
1452                                                         mpColorTable[ pTmp[ 4 ] ] ) );
1453             }
1454         }
1455     }
1456 }
1457
1458 // ------------------------------------------------------------------------
1459
1460 void PNGReaderImpl::ImplSetPixel( sal_uInt32 nY, sal_uInt32 nX, const BitmapColor& rBitmapColor )
1461 {
1462     // TODO: get preview mode checks out of inner loop
1463     if( nX & mnPreviewMask )
1464         return;
1465     nX >>= mnPreviewShift;
1466
1467     mpAcc->SetPixel( nY, nX, rBitmapColor );
1468 }
1469
1470 // ------------------------------------------------------------------------
1471
1472 void PNGReaderImpl::ImplSetPixel( sal_uInt32 nY, sal_uInt32 nX, BYTE nPalIndex )
1473 {
1474     // TODO: get preview mode checks out of inner loop
1475     if( nX & mnPreviewMask )
1476         return;
1477     nX >>= mnPreviewShift;
1478
1479     mpAcc->SetPixel( nY, nX, nPalIndex );
1480 }
1481
1482 // ------------------------------------------------------------------------
1483
1484 void PNGReaderImpl::ImplSetTranspPixel( sal_uInt32 nY, sal_uInt32 nX, const BitmapColor& rBitmapColor, BOOL bTrans )
1485 {
1486     // TODO: get preview mode checks out of inner loop
1487     if( nX & mnPreviewMask )
1488         return;
1489     nX >>= mnPreviewShift;
1490
1491     mpAcc->SetPixel( nY, nX, rBitmapColor );
1492
1493     if ( bTrans )
1494         mpMaskAcc->SetPixel( nY, nX, mcTranspColor );
1495     else
1496         mpMaskAcc->SetPixel( nY, nX, mcOpaqueColor );
1497 }
1498
1499 // ------------------------------------------------------------------------
1500
1501 void PNGReaderImpl::ImplSetAlphaPixel( sal_uInt32 nY, sal_uInt32 nX,
1502     BYTE nPalIndex, BYTE nAlpha )
1503 {
1504     // TODO: get preview mode checks out of inner loop
1505     if( nX & mnPreviewMask )
1506         return;
1507     nX >>= mnPreviewShift;
1508
1509     mpAcc->SetPixel( nY, nX, nPalIndex );
1510     mpMaskAcc->SetPixel( nY, nX, ~nAlpha );
1511 }
1512
1513 // ------------------------------------------------------------------------
1514
1515 void PNGReaderImpl::ImplSetAlphaPixel( sal_uInt32 nY, sal_uInt32 nX,
1516     const BitmapColor& rBitmapColor, BYTE nAlpha )
1517 {
1518     // TODO: get preview mode checks out of inner loop
1519     if( nX & mnPreviewMask )
1520         return;
1521     nX >>= mnPreviewShift;
1522
1523     mpAcc->SetPixel( nY, nX, rBitmapColor );
1524     mpMaskAcc->SetPixel( nY, nX, ~nAlpha );
1525 }
1526
1527 // ------------------------------------------------------------------------
1528
1529 sal_uInt32 PNGReaderImpl::ImplReadsal_uInt32()
1530 {
1531     sal_uInt32 nRet;
1532     nRet = *maDataIter++;
1533     nRet <<= 8;
1534     nRet |= *maDataIter++;
1535     nRet <<= 8;
1536     nRet |= *maDataIter++;
1537     nRet <<= 8;
1538     nRet |= *maDataIter++;
1539     return nRet;
1540 }
1541
1542 // ------------------------------------------------------------------------
1543
1544 // -------------
1545 // - PNGReader -
1546 // -------------
1547
1548 PNGReader::PNGReader( SvStream& rIStm ) :
1549     mpImpl( new ::vcl::PNGReaderImpl( rIStm ) )
1550 {
1551 }
1552
1553 // ------------------------------------------------------------------------
1554
1555 PNGReader::~PNGReader()
1556 {
1557     delete mpImpl;
1558 }
1559
1560 // ------------------------------------------------------------------------
1561
1562 BitmapEx PNGReader::Read( const Size& i_rPreviewSizeHint )
1563 {
1564     return mpImpl->GetBitmapEx( i_rPreviewSizeHint );
1565 }
1566
1567 // ------------------------------------------------------------------------
1568
1569 const std::vector< vcl::PNGReader::ChunkData >& PNGReader::GetChunks() const
1570 {
1571     return mpImpl->GetAllChunks();
1572 }
1573
1574 // ------------------------------------------------------------------------
1575
1576 void PNGReader::SetIgnoreGammaChunk( sal_Bool b )
1577 {
1578     mpImpl->SetIgnoreGammaChunk( b );
1579 }
1580
1581
1582 } // namespace vcl