vcl/source/gdi/pngwrite.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <vcl/pngwrite.hxx>
  21
  22 #include <cmath>
  23 #include <limits>
  24 #include <rtl/crc.h>
  25 #include <rtl/alloc.h>
  26 #include <tools/zcodec.hxx>
  27 #include <tools/stream.hxx>
  28 #include <vcl/bitmapaccess.hxx>
  29 #include <vcl/svapp.hxx>
  30 #include <vcl/alpha.hxx>
  31 #include <osl/endian.h>
  32 #include <memory>
  33
  34 #define PNG_DEF_COMPRESSION 6
  35
  36 #define PNGCHUNK_IHDR 0x49484452
  37 #define PNGCHUNK_PLTE 0x504c5445
  38 #define PNGCHUNK_IDAT 0x49444154
  39 #define PNGCHUNK_IEND 0x49454e44
  40 #define PNGCHUNK_pHYs 0x70485973
  41 #define PNGCHUNK_tRNS 0x74524e53
  42
  43 namespace vcl
  44 {
  45
  46 class PNGWriterImpl
  47 {
  48 public:
  49
  50     PNGWriterImpl(const BitmapEx& BmpEx,
  51                   const css::uno::Sequence<css::beans::PropertyValue>* pFilterData);
  52
  53     bool Write(SvStream& rOutStream);
  54
  55     std::vector<vcl::PNGWriter::ChunkData>& GetChunks()
  56     {
  57         return maChunkSeq;
  58     }
  59
  60 private:
  61
  62     std::vector<vcl::PNGWriter::ChunkData> maChunkSeq;
  63
  64     sal_Int32 mnCompLevel;
  65     sal_Int32 mnInterlaced;
  66     sal_uInt32 mnMaxChunkSize;
  67     bool mbStatus;
  68
  69     Bitmap::ScopedReadAccess mpAccess;
  70     BitmapReadAccess* mpMaskAccess;
  71     ZCodec mpZCodec;
  72
  73     sal_uInt8* mpDeflateInBuf;         // as big as the size of a scanline + alphachannel + 1
  74     sal_uInt8* mpPreviousScan;         // as big as mpDeflateInBuf
  75     sal_uInt8* mpCurrentScan;
  76     sal_uLong mnDeflateInSize;
  77
  78     sal_uLong mnWidth;
  79     sal_uLong mnHeight;
  80     sal_uInt8 mnBitsPerPixel;
  81     sal_uInt8 mnFilterType;  // 0 or 4;
  82     sal_uLong mnBBP;         // bytes per pixel ( needed for filtering )
  83     bool mbTrueAlpha;
  84     sal_uLong mnCRC;
  85
  86     void ImplWritepHYs(const BitmapEx& rBitmapEx);
  87     void ImplWriteIDAT();
  88     sal_uLong ImplGetFilter(sal_uLong nY, sal_uLong nXStart = 0, sal_uLong nXAdd = 1);
  89     void ImplClearFirstScanline();
  90     void ImplWriteTransparent();
  91     bool ImplWriteHeader();
  92     void ImplWritePalette();
  93     void ImplOpenChunk(sal_uLong nChunkType);
  94     void ImplWriteChunk(sal_uInt8 nNumb);
  95     void ImplWriteChunk(sal_uInt32 nNumb);
  96     void ImplWriteChunk(unsigned char* pSource, sal_uInt32 nDatSize);
  97 };
  98
  99 PNGWriterImpl::PNGWriterImpl( const BitmapEx& rBmpEx,
 100     const css::uno::Sequence<css::beans::PropertyValue>* pFilterData )
 101     : mnCompLevel(PNG_DEF_COMPRESSION)
 102     , mnInterlaced(0)
 103     , mnMaxChunkSize(0)
 104     , mbStatus(true)
 105     , mpMaskAccess(nullptr)
 106     , mpDeflateInBuf(nullptr)
 107     , mpPreviousScan(nullptr)
 108     , mpCurrentScan(nullptr)
 109     , mnDeflateInSize(0)
 110     , mnWidth(0)
 111     , mnHeight(0)
 112     , mnBitsPerPixel(0)
 113     , mnFilterType(0)
 114     , mnBBP(0)
 115     , mbTrueAlpha(false)
 116     , mnCRC(0UL)
 117 {
 118     if (!rBmpEx.IsEmpty())
 119     {
 120         Bitmap aBmp(rBmpEx.GetBitmap());
 121
 122         mnInterlaced = 0; // ( aBmp.GetSizePixel().Width() > 128 ) || ( aBmp.GetSizePixel().Height() > 128 ) ? 1 : 0; #i67236#
 123
 124         // #i67234# defaulting max chunk size to 256kb when using interlace mode
 125         mnMaxChunkSize = mnInterlaced == 0 ? std::numeric_limits<sal_uInt32>::max() : 0x40000;
 126
 127         if (pFilterData)
 128         {
 129             sal_Int32 i = 0;
 130             for (i = 0; i < pFilterData->getLength(); i++)
 131             {
 132                 if ((*pFilterData)[i].Name == "Compression")
 133                     (*pFilterData)[i].Value >>= mnCompLevel;
 134                 else if ((*pFilterData)[i].Name == "Interlaced")
 135                     (*pFilterData)[i].Value >>= mnInterlaced;
 136                 else if ((*pFilterData)[i].Name == "MaxChunkSize")
 137                 {
 138                     sal_Int32 nVal = 0;
 139                     if ((*pFilterData)[i].Value >>= nVal)
 140                         mnMaxChunkSize = static_cast<sal_uInt32>(nVal);
 141                 }
 142             }
 143         }
 144         mnBitsPerPixel = static_cast<sal_uInt8>(aBmp.GetBitCount());
 145
 146         if (rBmpEx.IsTransparent())
 147         {
 148             if (mnBitsPerPixel <= 8 && rBmpEx.IsAlpha())
 149             {
 150                 aBmp.Convert( BmpConversion::N24Bit );
 151                 mnBitsPerPixel = 24;
 152             }
 153
 154             if (mnBitsPerPixel <= 8) // transparent palette
 155             {
 156                 aBmp.Convert(BmpConversion::N8BitTrans);
 157                 aBmp.Replace(rBmpEx.GetMask(), BMP_COL_TRANS);
 158                 mnBitsPerPixel = 8;
 159                 mpAccess = Bitmap::ScopedReadAccess(aBmp);
 160                 if (mpAccess)
 161                 {
 162                     if (ImplWriteHeader())
 163                     {
 164                         ImplWritepHYs(rBmpEx);
 165                         ImplWritePalette();
 166                         ImplWriteTransparent();
 167                         ImplWriteIDAT();
 168                     }
 169                     mpAccess.reset();
 170                 }
 171                 else
 172                 {
 173                     mbStatus = false;
 174                 }
 175             }
 176             else
 177             {
 178                 mpAccess = Bitmap::ScopedReadAccess(aBmp); // true RGB with alphachannel
 179                 if (mpAccess)
 180                 {
 181                     mbTrueAlpha = rBmpEx.IsAlpha();
 182                     if (mbTrueAlpha)
 183                     {
 184                         AlphaMask aMask(rBmpEx.GetAlpha());
 185                         mpMaskAccess = aMask.AcquireReadAccess();
 186                         if (mpMaskAccess)
 187                         {
 188                             if (ImplWriteHeader())
 189                             {
 190                                 ImplWritepHYs(rBmpEx);
 191                                 ImplWriteIDAT();
 192                             }
 193                             aMask.ReleaseAccess(mpMaskAccess);
 194                             mpMaskAccess = nullptr;
 195                         }
 196                         else
 197                         {
 198                             mbStatus = false;
 199                         }
 200                     }
 201                     else
 202                     {
 203                         Bitmap aMask(rBmpEx.GetMask());
 204                         mpMaskAccess = aMask.AcquireReadAccess();
 205                         if (mpMaskAccess)
 206                         {
 207                             if (ImplWriteHeader())
 208                             {
 209                                 ImplWritepHYs(rBmpEx);
 210                                 ImplWriteIDAT();
 211                             }
 212                             Bitmap::ReleaseAccess(mpMaskAccess);
 213                             mpMaskAccess = nullptr;
 214                         }
 215                         else
 216                         {
 217                             mbStatus = false;
 218                         }
 219                     }
 220                     mpAccess.reset();
 221                 }
 222                 else
 223                 {
 224                     mbStatus = false;
 225                 }
 226             }
 227         }
 228         else
 229         {
 230             mpAccess = Bitmap::ScopedReadAccess(aBmp); // palette + RGB without alphachannel
 231             if (mpAccess)
 232             {
 233                 if (ImplWriteHeader())
 234                 {
 235                     ImplWritepHYs(rBmpEx);
 236                     if (mpAccess->HasPalette())
 237                         ImplWritePalette();
 238
 239                     ImplWriteIDAT();
 240                 }
 241                 mpAccess.reset();
 242             }
 243             else
 244             {
 245                 mbStatus = false;
 246             }
 247         }
 248
 249         if (mbStatus)
 250         {
 251             ImplOpenChunk(PNGCHUNK_IEND); // create an IEND chunk
 252         }
 253     }
 254 }
 255
 256 bool PNGWriterImpl::Write(SvStream& rOStm)
 257 {
 258    /* png signature is always an array of 8 bytes */
 259     SvStreamEndian nOldMode = rOStm.GetEndian();
 260     rOStm.SetEndian(SvStreamEndian::BIG);
 261     rOStm.WriteUInt32(0x89504e47);
 262     rOStm.WriteUInt32(0x0d0a1a0a);
 263
 264     std::vector< vcl::PNGWriter::ChunkData >::iterator aBeg(maChunkSeq.begin());
 265     std::vector< vcl::PNGWriter::ChunkData >::iterator aEnd(maChunkSeq.end());
 266     while (aBeg != aEnd)
 267     {
 268         sal_uInt32 nType = aBeg->nType;
 269     #if defined(__LITTLEENDIAN) || defined(OSL_LITENDIAN)
 270         nType = OSL_SWAPDWORD(nType);
 271     #endif
 272         sal_uInt32 nCRC = rtl_crc32(0, &nType, 4);
 273         sal_uInt32 nDataSize = aBeg->aData.size();
 274         if (nDataSize)
 275             nCRC = rtl_crc32(nCRC, &aBeg->aData[0], nDataSize);
 276         rOStm.WriteUInt32(nDataSize);
 277         rOStm.WriteUInt32(aBeg->nType);
 278         if (nDataSize)
 279             rOStm.WriteBytes(&aBeg->aData[0], nDataSize);
 280         rOStm.WriteUInt32(nCRC);
 281         ++aBeg;
 282     }
 283     rOStm.SetEndian(nOldMode);
 284     return mbStatus;
 285 }
 286
 287
 288 bool PNGWriterImpl::ImplWriteHeader()
 289 {
 290     ImplOpenChunk(PNGCHUNK_IHDR);
 291     ImplWriteChunk(sal_uInt32(mnWidth =  mpAccess->Width()));
 292     ImplWriteChunk(sal_uInt32(mnHeight = mpAccess->Height()));
 293
 294     if (mnWidth && mnHeight && mnBitsPerPixel && mbStatus)
 295     {
 296         sal_uInt8 nBitDepth = mnBitsPerPixel;
 297         if (mnBitsPerPixel <= 8)
 298             mnFilterType = 0;
 299         else
 300             mnFilterType = 4;
 301
 302         sal_uInt8 nColorType = 2; // colortype:
 303
 304                                     // bit 0 -> palette is used
 305         if (mpAccess->HasPalette()) // bit 1 -> color is used
 306             nColorType |= 1;        // bit 2 -> alpha channel is used
 307         else
 308             nBitDepth /= 3;
 309
 310         if (mpMaskAccess)
 311             nColorType |= 4;
 312
 313         ImplWriteChunk(nBitDepth);
 314         ImplWriteChunk(nColorType); // colortype
 315         ImplWriteChunk(static_cast<sal_uInt8>(0)); // compression type
 316         ImplWriteChunk(static_cast<sal_uInt8>(0)); // filter type - is not supported in this version
 317         ImplWriteChunk(static_cast<sal_uInt8>(mnInterlaced)); // interlace type
 318     }
 319     else
 320     {
 321         mbStatus = false;
 322     }
 323     return mbStatus;
 324 }
 325
 326 void PNGWriterImpl::ImplWritePalette()
 327 {
 328     const sal_uLong nCount = mpAccess->GetPaletteEntryCount();
 329     std::unique_ptr<sal_uInt8[]> pTempBuf(new sal_uInt8[nCount * 3]);
 330     sal_uInt8* pTmp = pTempBuf.get();
 331
 332     ImplOpenChunk(PNGCHUNK_PLTE);
 333
 334     for ( sal_uLong i = 0; i < nCount; i++ )
 335     {
 336         const BitmapColor& rColor = mpAccess->GetPaletteColor(i);
 337         *pTmp++ = rColor.GetRed();
 338         *pTmp++ = rColor.GetGreen();
 339         *pTmp++ = rColor.GetBlue();
 340     }
 341     ImplWriteChunk(pTempBuf.get(), nCount * 3);
 342 }
 343
 344 void PNGWriterImpl::ImplWriteTransparent()
 345 {
 346     const sal_uLong nTransIndex = mpAccess->GetBestPaletteIndex(BMP_COL_TRANS);
 347
 348     ImplOpenChunk(PNGCHUNK_tRNS);
 349
 350     for (sal_uLong n = 0UL; n <= nTransIndex; n++)
 351     {
 352         ImplWriteChunk((nTransIndex == n) ? static_cast<sal_uInt8>(0x0) : static_cast<sal_uInt8>(0xff));
 353     }
 354 }
 355
 356 void PNGWriterImpl::ImplWritepHYs(const BitmapEx& rBmpEx)
 357 {
 358     if (rBmpEx.GetPrefMapMode() == MapUnit::Map100thMM)
 359     {
 360         Size aPrefSize(rBmpEx.GetPrefSize());
 361
 362         if (aPrefSize.Width() && aPrefSize.Height() && mnWidth && mnHeight)
 363         {
 364             ImplOpenChunk(PNGCHUNK_pHYs);
 365             sal_uInt8 nMapUnit = 1;
 366             sal_uInt32 nPrefSizeX = static_cast<sal_uInt32>(100000.0 / (static_cast<double>(aPrefSize.Width()) / mnWidth) + 0.5);
 367             sal_uInt32 nPrefSizeY = static_cast<sal_uInt32>(100000.0 / (static_cast<double>(aPrefSize.Height()) / mnHeight) + 0.5);
 368             ImplWriteChunk(nPrefSizeX);
 369             ImplWriteChunk(nPrefSizeY);
 370             ImplWriteChunk(nMapUnit);
 371         }
 372     }
 373 }
 374
 375 void PNGWriterImpl::ImplWriteIDAT()
 376 {
 377     mnDeflateInSize = mnBitsPerPixel;
 378
 379     if (mpMaskAccess)
 380         mnDeflateInSize += 8;
 381
 382     mnBBP = (mnDeflateInSize + 7) >> 3;
 383
 384     mnDeflateInSize = mnBBP * mnWidth + 1;
 385
 386     mpDeflateInBuf = new sal_uInt8[mnDeflateInSize];
 387
 388     if (mnFilterType) // using filter type 4 we need memory for the scanline 3 times
 389     {
 390         mpPreviousScan = new sal_uInt8[mnDeflateInSize];
 391         mpCurrentScan = new sal_uInt8[mnDeflateInSize];
 392         ImplClearFirstScanline();
 393     }
 394     mpZCodec.BeginCompression(mnCompLevel, true);
 395     mpZCodec.SetCRC(mnCRC);
 396     SvMemoryStream aOStm;
 397     if (mnInterlaced == 0)
 398     {
 399         for (sal_uLong nY = 0; nY < mnHeight; nY++)
 400         {
 401             mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY));
 402         }
 403     }
 404     else
 405     {
 406         // interlace mode
 407         sal_uLong nY;
 408         for (nY = 0; nY < mnHeight; nY += 8) // pass 1
 409         {
 410             mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 8));
 411         }
 412         ImplClearFirstScanline();
 413
 414         for (nY = 0; nY < mnHeight; nY += 8) // pass 2
 415         {
 416             mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 4, 8));
 417         }
 418         ImplClearFirstScanline();
 419
 420         if (mnHeight >= 5) // pass 3
 421         {
 422             for (nY = 4; nY < mnHeight; nY += 8)
 423             {
 424                 mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 4));
 425             }
 426             ImplClearFirstScanline();
 427         }
 428
 429         for (nY = 0; nY < mnHeight; nY += 4) // pass 4
 430         {
 431             mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 2, 4));
 432         }
 433         ImplClearFirstScanline();
 434
 435         if (mnHeight >= 3) // pass 5
 436         {
 437             for (nY = 2; nY < mnHeight; nY += 4)
 438             {
 439                 mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 2));
 440             }
 441             ImplClearFirstScanline();
 442         }
 443
 444         for (nY = 0; nY < mnHeight; nY += 2) // pass 6
 445         {
 446             mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 1, 2));
 447         }
 448         ImplClearFirstScanline();
 449
 450         if (mnHeight >= 2) // pass 7
 451         {
 452             for (nY = 1; nY < mnHeight; nY += 2)
 453             {
 454                 mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter (nY));
 455             }
 456         }
 457     }
 458     mpZCodec.EndCompression();
 459     mnCRC = mpZCodec.GetCRC();
 460
 461     if (mnFilterType) // using filter type 4 we need memory for the scanline 3 times
 462     {
 463         delete[] mpCurrentScan;
 464         delete[] mpPreviousScan;
 465     }
 466     delete[] mpDeflateInBuf;
 467
 468     sal_uInt32 nIDATSize = aOStm.Tell();
 469     sal_uInt32 nBytes, nBytesToWrite = nIDATSize;
 470     while(nBytesToWrite)
 471     {
 472         nBytes = nBytesToWrite <= mnMaxChunkSize ? nBytesToWrite : mnMaxChunkSize;
 473         ImplOpenChunk(PNGCHUNK_IDAT);
 474         ImplWriteChunk(const_cast<unsigned char *>(static_cast<unsigned char const *>(aOStm.GetData())) + (nIDATSize - nBytesToWrite), nBytes);
 475         nBytesToWrite -= nBytes;
 476     }
 477 }
 478
 479 // ImplGetFilter writes the complete Scanline (nY) - in interlace mode the parameter nXStart and nXAdd
 480 // appends to the currently used pass
 481 // the complete size of scanline will be returned - in interlace mode zero is possible!
 482
 483 sal_uLong PNGWriterImpl::ImplGetFilter (sal_uLong nY, sal_uLong nXStart, sal_uLong nXAdd)
 484 {
 485     sal_uInt8* pDest;
 486
 487     if (mnFilterType)
 488         pDest = mpCurrentScan;
 489     else
 490         pDest = mpDeflateInBuf;
 491
 492     if (nXStart < mnWidth)
 493     {
 494         *pDest++ = mnFilterType; // in this version the filter type is either 0 or 4
 495
 496         if (mpAccess->HasPalette()) // alphachannel is not allowed by pictures including palette entries
 497         {
 498             switch (mnBitsPerPixel)
 499             {
 500                 case 1:
 501                 {
 502                     sal_uLong nX, nXIndex;
 503                     for (nX = nXStart, nXIndex = 0; nX < mnWidth; nX += nXAdd, nXIndex++)
 504                     {
 505                         sal_uLong nShift = (nXIndex & 7) ^ 7;
 506                         if (nShift == 7)
 507                             *pDest = mpAccess->GetPixelIndex(nY, nX) << nShift;
 508                         else if  (nShift == 0)
 509                             *pDest++ |= mpAccess->GetPixelIndex(nY, nX) << nShift;
 510                         else
 511                             *pDest |= mpAccess->GetPixelIndex(nY, nX) << nShift;
 512                     }
 513                     if ( (nXIndex & 7) != 0 )
 514                         pDest++;    // byte is not completely used, so the bufferpointer is to correct
 515                 }
 516                 break;
 517
 518                 case 4:
 519                 {
 520                     sal_uLong nX, nXIndex;
 521                     for (nX = nXStart, nXIndex = 0; nX < mnWidth; nX += nXAdd, nXIndex++)
 522                     {
 523                         if(nXIndex & 1)
 524                             *pDest++ |= mpAccess->GetPixelIndex(nY, nX);
 525                         else
 526                             *pDest = mpAccess->GetPixelIndex(nY, nX) << 4;
 527                     }
 528                     if (nXIndex & 1)
 529                         pDest++;
 530                 }
 531                 break;
 532
 533                 case 8:
 534                 {
 535                     for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
 536                     {
 537                         *pDest++ = mpAccess->GetPixelIndex( nY, nX );
 538                     }
 539                 }
 540                 break;
 541
 542                 default :
 543                     mbStatus = false;
 544                 break;
 545             }
 546         }
 547         else
 548         {
 549             if (mpMaskAccess) // mpMaskAccess != NULL -> alphachannel is to create
 550             {
 551                 if (mbTrueAlpha)
 552                 {
 553                     for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
 554                     {
 555                         const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
 556                         *pDest++ = rColor.GetRed();
 557                         *pDest++ = rColor.GetGreen();
 558                         *pDest++ = rColor.GetBlue();
 559                         *pDest++ = 255 - mpMaskAccess->GetPixelIndex(nY, nX);
 560                     }
 561                 }
 562                 else
 563                 {
 564                     const BitmapColor aTrans(mpMaskAccess->GetBestMatchingColor(Color(COL_WHITE)));
 565
 566                     for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
 567                     {
 568                         const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
 569                         *pDest++ = rColor.GetRed();
 570                         *pDest++ = rColor.GetGreen();
 571                         *pDest++ = rColor.GetBlue();
 572
 573                         if(mpMaskAccess->GetPixel(nY, nX) == aTrans)
 574                             *pDest++ = 0;
 575                         else
 576                             *pDest++ = 0xff;
 577                     }
 578                 }
 579             }
 580             else
 581             {
 582                 for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
 583                 {
 584                     const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
 585                     *pDest++ = rColor.GetRed();
 586                     *pDest++ = rColor.GetGreen();
 587                     *pDest++ = rColor.GetBlue();
 588                 }
 589             }
 590         }
 591     }
 592     // filter type4 ( PAETH ) will be used only for 24bit graphics
 593     if (mnFilterType)
 594     {
 595         mnDeflateInSize = pDest - mpCurrentScan;
 596         pDest = mpDeflateInBuf;
 597         *pDest++ = 4; // filter type
 598
 599         sal_uInt8* p1 = mpCurrentScan + 1; // Current Pixel
 600         sal_uInt8* p2 = p1 - mnBBP;        // left pixel
 601         sal_uInt8* p3 = mpPreviousScan;    // upper pixel
 602         sal_uInt8* p4 = p3 - mnBBP;        // upperleft Pixel;
 603
 604         while (pDest < mpDeflateInBuf + mnDeflateInSize)
 605         {
 606             sal_uLong nb = *p3++;
 607             sal_uLong na, nc;
 608             if (p2 >= mpCurrentScan + 1)
 609             {
 610                 na = *p2;
 611                 nc = *p4;
 612             }
 613             else
 614             {
 615                 na = nc = 0;
 616             }
 617
 618             long np = na + nb - nc;
 619             long npa = np - na;
 620             long npb = np - nb;
 621             long npc = np - nc;
 622
 623             if (npa < 0)
 624                 npa =-npa;
 625             if (npb < 0)
 626                 npb =-npb;
 627             if (npc < 0)
 628                 npc =-npc;
 629
 630             if (npa <= npb && npa <= npc)
 631                 *pDest++ = *p1++ - static_cast<sal_uInt8>(na);
 632             else if ( npb <= npc )
 633                 *pDest++ = *p1++ - static_cast<sal_uInt8>(nb);
 634             else
 635                 *pDest++ = *p1++ - static_cast<sal_uInt8>(nc);
 636
 637             p4++;
 638             p2++;
 639         }
 640         for (long i = 0; i < static_cast<long>(mnDeflateInSize - 1); i++)
 641         {
 642             mpPreviousScan[i] = mpCurrentScan[i + 1];
 643         }
 644     }
 645     else
 646     {
 647         mnDeflateInSize = pDest - mpDeflateInBuf;
 648     }
 649     return mnDeflateInSize;
 650 }
 651
 652 void PNGWriterImpl::ImplClearFirstScanline()
 653 {
 654     if (mnFilterType)
 655         memset(mpPreviousScan, 0, mnDeflateInSize);
 656 }
 657
 658 void PNGWriterImpl::ImplOpenChunk (sal_uLong nChunkType)
 659 {
 660     maChunkSeq.resize(maChunkSeq.size() + 1);
 661     maChunkSeq.back().nType = nChunkType;
 662 }
 663
 664 void PNGWriterImpl::ImplWriteChunk (sal_uInt8 nSource)
 665 {
 666     maChunkSeq.back().aData.push_back(nSource);
 667 }
 668
 669 void PNGWriterImpl::ImplWriteChunk (sal_uInt32 nSource)
 670 {
 671     vcl::PNGWriter::ChunkData& rChunkData = maChunkSeq.back();
 672     rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 24));
 673     rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 16));
 674     rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 8));
 675     rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource));
 676 }
 677
 678 void PNGWriterImpl::ImplWriteChunk (unsigned char* pSource, sal_uInt32 nDatSize)
 679 {
 680     if (nDatSize)
 681     {
 682         vcl::PNGWriter::ChunkData& rChunkData = maChunkSeq.back();
 683         sal_uInt32 nSize = rChunkData.aData.size();
 684         rChunkData.aData.resize(nSize + nDatSize);
 685         memcpy(&rChunkData.aData[nSize], pSource, nDatSize);
 686     }
 687 }
 688
 689 PNGWriter::PNGWriter(const BitmapEx& rBmpEx,
 690                      const css::uno::Sequence<css::beans::PropertyValue>* pFilterData)
 691     : mpImpl(new vcl::PNGWriterImpl(rBmpEx, pFilterData))
 692 {
 693 }
 694
 695 PNGWriter::~PNGWriter()
 696 {
 697 }
 698
 699 bool PNGWriter::Write(SvStream& rStream)
 700 {
 701     return mpImpl->Write(rStream);
 702 }
 703
 704 std::vector<vcl::PNGWriter::ChunkData>& PNGWriter::GetChunks()
 705 {
 706     return mpImpl->GetChunks();
 707 }
 708
 709 } // namespace vcl
 710
 711 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */