cleanup pngwrite, use const std::unique_ptr for pImpl

Change-Id: I7c9941731789be3553d473d64716484bfceaf8b4

2 files changed, 303 insertions, 251 deletions

diff --git a/include/vcl/pngwrite.hxx b/include/vcl/pngwrite.hxx
index dfdd84667b74..bb32b2e0173c 100644
--- a/include/vcl/pngwrite.hxx
+++ b/include/vcl/pngwrite.hxx
@@ -26,33 +26,28 @@
 #include <vcl/bitmapex.hxx>
 #include <vector>
 
-
-// - PNGWriter -
-
-
 namespace vcl
 {
     class PNGWriterImpl;
 
     class VCL_DLLPUBLIC PNGWriter
     {
-        PNGWriterImpl*          mpImpl;
+        const std::unique_ptr<PNGWriterImpl> mpImpl;
 
     public:
 
-        explicit PNGWriter( const BitmapEx&,
-            const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData = NULL );
+        explicit PNGWriter(const BitmapEx&, const css::uno::Sequence<css::beans::PropertyValue>* pFilterData = NULL);
         ~PNGWriter();
 
-        bool Write( SvStream& rStm );
+        bool Write(SvStream& rStream);
 
         // additional method to be able to modify all chunk before they are stored
         struct ChunkData
         {
             sal_uInt32                  nType;
-            std::vector< sal_uInt8 >    aData;
+            std::vector<sal_uInt8>    aData;
         };
-        std::vector< vcl::PNGWriter::ChunkData >& GetChunks();
+        std::vector<vcl::PNGWriter::ChunkData>& GetChunks();
     };
 }
 
diff --git a/vcl/source/gdi/pngwrite.cxx b/vcl/source/gdi/pngwrite.cxx
index 800b3d7ba393..ac9bdd2da454 100644
--- a/vcl/source/gdi/pngwrite.cxx
+++ b/vcl/source/gdi/pngwrite.cxx
@@ -47,53 +47,57 @@ class PNGWriterImpl
 {
 public:
 
-                PNGWriterImpl( const BitmapEx& BmpEx,
-                    const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData = NULL );
+    PNGWriterImpl(const BitmapEx& BmpEx,
+                  const css::uno::Sequence<css::beans::PropertyValue>* pFilterData = NULL);
 
-    bool    Write( SvStream& rOStm );
+    bool Write(SvStream& rOutStream);
 
-    std::vector< vcl::PNGWriter::ChunkData >&   GetChunks() { return maChunkSeq;}
+    std::vector<vcl::PNGWriter::ChunkData>& GetChunks()
+    {
+        return maChunkSeq;
+    }
 
 private:
 
-    std::vector< vcl::PNGWriter::ChunkData >    maChunkSeq;
-
-    sal_Int32           mnCompLevel;
-    sal_Int32           mnInterlaced;
-    sal_uInt32          mnMaxChunkSize;
-    bool                mbStatus;
-
-    BitmapReadAccess*   mpAccess;
-    BitmapReadAccess*   mpMaskAccess;
-    ZCodec              mpZCodec;
-
-    sal_uInt8*              mpDeflateInBuf;         // as big as the size of a scanline + alphachannel + 1
-    sal_uInt8*              mpPreviousScan;         // as big as mpDeflateInBuf
-    sal_uInt8*              mpCurrentScan;
-    sal_uLong               mnDeflateInSize;
-
-    sal_uLong               mnWidth, mnHeight;
-    sal_uInt8               mnBitsPerPixel;
-    sal_uInt8               mnFilterType;           // 0 oder 4;
-    sal_uLong               mnBBP;                  // bytes per pixel ( needed for filtering )
-    bool                mbTrueAlpha;
-    sal_uLong               mnCRC;
-
-    void                ImplWritepHYs( const BitmapEx& rBitmapEx );
-    void                ImplWriteIDAT();
-    sal_uLong               ImplGetFilter( sal_uLong nY, sal_uLong nXStart=0, sal_uLong nXAdd=1 );
-    void                ImplClearFirstScanline();
-    void                ImplWriteTransparent();
-    bool                ImplWriteHeader();
-    void                ImplWritePalette();
-    void                ImplOpenChunk( sal_uLong nChunkType );
-    void                ImplWriteChunk( sal_uInt8 nNumb );
-    void                ImplWriteChunk( sal_uInt32 nNumb );
-    void                ImplWriteChunk( unsigned char* pSource, sal_uInt32 nDatSize );
+    std::vector<vcl::PNGWriter::ChunkData> maChunkSeq;
+
+    sal_Int32 mnCompLevel;
+    sal_Int32 mnInterlaced;
+    sal_uInt32 mnMaxChunkSize;
+    bool mbStatus;
+
+    BitmapReadAccess* mpAccess;
+    BitmapReadAccess* mpMaskAccess;
+    ZCodec mpZCodec;
+
+    sal_uInt8* mpDeflateInBuf;         // as big as the size of a scanline + alphachannel + 1
+    sal_uInt8* mpPreviousScan;         // as big as mpDeflateInBuf
+    sal_uInt8* mpCurrentScan;
+    sal_uLong mnDeflateInSize;
+
+    sal_uLong mnWidth;
+    sal_uLong mnHeight;
+    sal_uInt8 mnBitsPerPixel;
+    sal_uInt8 mnFilterType;  // 0 oder 4;
+    sal_uLong mnBBP;         // bytes per pixel ( needed for filtering )
+    bool mbTrueAlpha;
+    sal_uLong mnCRC;
+
+    void ImplWritepHYs(const BitmapEx& rBitmapEx);
+    void ImplWriteIDAT();
+    sal_uLong ImplGetFilter(sal_uLong nY, sal_uLong nXStart = 0, sal_uLong nXAdd = 1);
+    void ImplClearFirstScanline();
+    void ImplWriteTransparent();
+    bool ImplWriteHeader();
+    void ImplWritePalette();
+    void ImplOpenChunk(sal_uLong nChunkType);
+    void ImplWriteChunk(sal_uInt8 nNumb);
+    void ImplWriteChunk(sal_uInt32 nNumb);
+    void ImplWriteChunk(unsigned char* pSource, sal_uInt32 nDatSize);
 };
 
 PNGWriterImpl::PNGWriterImpl( const BitmapEx& rBmpEx,
-    const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData )
+    const css::uno::Sequence<css::beans::PropertyValue>* pFilterData )
     : mnCompLevel(PNG_DEF_COMPRESSION)
     , mnInterlaced(0)
     , mnMaxChunkSize(0)
@@ -112,158 +116,174 @@ PNGWriterImpl::PNGWriterImpl( const BitmapEx& rBmpEx,
     , mbTrueAlpha(false)
     , mnCRC(0UL)
 {
-    if ( !rBmpEx.IsEmpty() )
+    if (!rBmpEx.IsEmpty())
     {
-        Bitmap aBmp( rBmpEx.GetBitmap() );
+        Bitmap aBmp(rBmpEx.GetBitmap());
 
-        mnInterlaced = 0;   // ( aBmp.GetSizePixel().Width() > 128 ) || ( aBmp.GetSizePixel().Height() > 128 ) ? 1 : 0; #i67236#
+        mnInterlaced = 0; // ( aBmp.GetSizePixel().Width() > 128 ) || ( aBmp.GetSizePixel().Height() > 128 ) ? 1 : 0; #i67236#
 
         // #i67234# defaulting max chunk size to 256kb when using interlace mode
-        mnMaxChunkSize = mnInterlaced == 0 ? std::numeric_limits< sal_uInt32 >::max() : 0x40000;
+        mnMaxChunkSize = mnInterlaced == 0 ? std::numeric_limits<sal_uInt32>::max() : 0x40000;
 
-        if ( pFilterData )
+        if (pFilterData)
         {
             sal_Int32 i = 0;
-            for ( i = 0; i < pFilterData->getLength(); i++ )
+            for (i = 0; i < pFilterData->getLength(); i++)
             {
-                if ( (*pFilterData)[ i ].Name == "Compression" )
-                    (*pFilterData)[ i ].Value >>= mnCompLevel;
-                else if ( (*pFilterData)[ i ].Name == "Interlaced" )
-                    (*pFilterData)[ i ].Value >>= mnInterlaced;
-                else if ( (*pFilterData)[ i ].Name == "MaxChunkSize" )
+                if ((*pFilterData)[i].Name == "Compression")
+                    (*pFilterData)[i].Value >>= mnCompLevel;
+                else if ((*pFilterData)[i].Name == "Interlaced")
+                    (*pFilterData)[i].Value >>= mnInterlaced;
+                else if ((*pFilterData)[i].Name == "MaxChunkSize")
                 {
                     sal_Int32 nVal = 0;
-                    if ( (*pFilterData)[ i ].Value >>= nVal )
-                        mnMaxChunkSize = (sal_uInt32)nVal;
+                    if ((*pFilterData)[i].Value >>= nVal)
+                        mnMaxChunkSize = static_cast<sal_uInt32>(nVal);
                 }
             }
         }
-        mnBitsPerPixel = (sal_uInt8)aBmp.GetBitCount();
+        mnBitsPerPixel = static_cast<sal_uInt8>(aBmp.GetBitCount());
 
-        if( rBmpEx.IsTransparent() )
+        if (rBmpEx.IsTransparent())
         {
-            if ( mnBitsPerPixel <= 8 && rBmpEx.IsAlpha() )
+            if (mnBitsPerPixel <= 8 && rBmpEx.IsAlpha())
             {
                 aBmp.Convert( BMP_CONVERSION_24BIT );
                 mnBitsPerPixel = 24;
             }
 
-            if ( mnBitsPerPixel <= 8 )                  // transparent palette
+            if (mnBitsPerPixel <= 8) // transparent palette
             {
-                aBmp.Convert( BMP_CONVERSION_8BIT_TRANS );
-                aBmp.Replace( rBmpEx.GetMask(), BMP_COL_TRANS );
+                aBmp.Convert(BMP_CONVERSION_8BIT_TRANS);
+                aBmp.Replace(rBmpEx.GetMask(), BMP_COL_TRANS);
                 mnBitsPerPixel = 8;
                 mpAccess = aBmp.AcquireReadAccess();
-                if ( mpAccess )
+                if (mpAccess)
                 {
-                    if ( ImplWriteHeader() )
+                    if (ImplWriteHeader())
                     {
-                        ImplWritepHYs( rBmpEx );
+                        ImplWritepHYs(rBmpEx);
                         ImplWritePalette();
                         ImplWriteTransparent();
                         ImplWriteIDAT();
                     }
-                    aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
+                    aBmp.ReleaseAccess(mpAccess);
+                    mpAccess = NULL;
                 }
                 else
+                {
                     mbStatus = false;
+                }
             }
             else
             {
-                mpAccess = aBmp.AcquireReadAccess();    // true RGB with alphachannel
-                if( mpAccess )
+                mpAccess = aBmp.AcquireReadAccess(); // true RGB with alphachannel
+                if (mpAccess)
                 {
-                    if ( ( mbTrueAlpha = rBmpEx.IsAlpha() ) )
+                    if ((mbTrueAlpha = rBmpEx.IsAlpha()))
                     {
-                        AlphaMask aMask( rBmpEx.GetAlpha() );
+                        AlphaMask aMask(rBmpEx.GetAlpha());
                         mpMaskAccess = aMask.AcquireReadAccess();
-                        if ( mpMaskAccess )
+                        if (mpMaskAccess)
                         {
-                            if ( ImplWriteHeader() )
+                            if (ImplWriteHeader())
                             {
-                                ImplWritepHYs( rBmpEx );
+                                ImplWritepHYs(rBmpEx);
                                 ImplWriteIDAT();
                             }
-                            aMask.ReleaseAccess( mpMaskAccess ), mpMaskAccess = 0;
+                            aMask.ReleaseAccess(mpMaskAccess);
+                            mpMaskAccess = NULL;
                         }
                         else
+                        {
                             mbStatus = false;
+                        }
                     }
                     else
                     {
-                        Bitmap aMask( rBmpEx.GetMask() );
+                        Bitmap aMask(rBmpEx.GetMask());
                         mpMaskAccess = aMask.AcquireReadAccess();
-                        if( mpMaskAccess )
+                        if (mpMaskAccess)
                         {
-                            if ( ImplWriteHeader() )
+                            if (ImplWriteHeader())
                             {
-                                ImplWritepHYs( rBmpEx );
+                                ImplWritepHYs(rBmpEx);
                                 ImplWriteIDAT();
                             }
-                            aMask.ReleaseAccess( mpMaskAccess ), mpMaskAccess = 0;
+                            aMask.ReleaseAccess(mpMaskAccess);
+                            mpMaskAccess = NULL;
                         }
                         else
+                        {
                             mbStatus = false;
+                        }
                     }
-                    aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
+                    aBmp.ReleaseAccess(mpAccess);
+                    mpAccess = NULL;
                 }
                 else
+                {
                     mbStatus = false;
+                }
             }
         }
         else
         {
-            mpAccess = aBmp.AcquireReadAccess();        // palette + RGB without alphachannel
-            if( mpAccess )
+            mpAccess = aBmp.AcquireReadAccess(); // palette + RGB without alphachannel
+            if (mpAccess)
             {
-                if ( ImplWriteHeader() )
+                if (ImplWriteHeader())
                 {
-                    ImplWritepHYs( rBmpEx );
-                    if( mpAccess->HasPalette() )
+                    ImplWritepHYs(rBmpEx);
+                    if (mpAccess->HasPalette())
                         ImplWritePalette();
 
                     ImplWriteIDAT();
                 }
-                aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
+                aBmp.ReleaseAccess(mpAccess);
+                mpAccess = NULL;
             }
             else
+            {
                 mbStatus = false;
+            }
         }
-        if ( mbStatus )
+
+        if (mbStatus)
         {
-            ImplOpenChunk( PNGCHUNK_IEND );     // create an IEND chunk
+            ImplOpenChunk(PNGCHUNK_IEND); // create an IEND chunk
         }
     }
 }
 
-bool PNGWriterImpl::Write( SvStream& rOStm )
+bool PNGWriterImpl::Write(SvStream& rOStm)
 {
    /* png signature is always an array of 8 bytes */
     SvStreamEndian nOldMode = rOStm.GetEndian();
-    rOStm.SetEndian( SvStreamEndian::BIG );
-    rOStm.WriteUInt32( 0x89504e47 );
-    rOStm.WriteUInt32( 0x0d0a1a0a );
+    rOStm.SetEndian(SvStreamEndian::BIG);
+    rOStm.WriteUInt32(0x89504e47);
+    rOStm.WriteUInt32(0x0d0a1a0a);
 
-    std::vector< vcl::PNGWriter::ChunkData >::iterator aBeg( maChunkSeq.begin() );
-    std::vector< vcl::PNGWriter::ChunkData >::iterator aEnd( maChunkSeq.end() );
-    while( aBeg != aEnd )
+    std::vector< vcl::PNGWriter::ChunkData >::iterator aBeg(maChunkSeq.begin());
+    std::vector< vcl::PNGWriter::ChunkData >::iterator aEnd(maChunkSeq.end());
+    while (aBeg != aEnd)
     {
         sal_uInt32 nType = aBeg->nType;
     #if defined(__LITTLEENDIAN) || defined(OSL_LITENDIAN)
-        nType = OSL_SWAPDWORD( nType );
+        nType = OSL_SWAPDWORD(nType);
     #endif
-        sal_uInt32 nCRC = rtl_crc32( 0, &nType, 4 );
+        sal_uInt32 nCRC = rtl_crc32(0, &nType, 4);
         sal_uInt32 nDataSize = aBeg->aData.size();
-        if ( nDataSize )
-            nCRC = rtl_crc32( nCRC, &aBeg->aData[ 0 ], nDataSize );
-        rOStm.WriteUInt32( nDataSize )
-             .WriteUInt32( aBeg->nType );
-        if ( nDataSize )
-            rOStm.Write( &aBeg->aData[ 0 ], nDataSize );
-        rOStm.WriteUInt32( nCRC );
+        if (nDataSize)
+            nCRC = rtl_crc32(nCRC, &aBeg->aData[0], nDataSize);
+        rOStm.WriteUInt32(nDataSize);
+        rOStm.WriteUInt32(aBeg->nType);
+        if (nDataSize)
+            rOStm.Write(&aBeg->aData[0], nDataSize);
+        rOStm.WriteUInt32(nCRC);
         ++aBeg;
     }
-    rOStm.SetEndian( nOldMode );
+    rOStm.SetEndian(nOldMode);
     return mbStatus;
 }
 
@@ -271,155 +291,177 @@ bool PNGWriterImpl::Write( SvStream& rOStm )
 bool PNGWriterImpl::ImplWriteHeader()
 {
     ImplOpenChunk(PNGCHUNK_IHDR);
-    ImplWriteChunk( sal_uInt32( mnWidth =  mpAccess->Width() ) );
-    ImplWriteChunk( sal_uInt32( mnHeight = mpAccess->Height() ) );
+    ImplWriteChunk(sal_uInt32(mnWidth =  mpAccess->Width()));
+    ImplWriteChunk(sal_uInt32(mnHeight = mpAccess->Height()));
 
-    if ( mnWidth && mnHeight && mnBitsPerPixel && mbStatus )
+    if (mnWidth && mnHeight && mnBitsPerPixel && mbStatus)
     {
         sal_uInt8 nBitDepth = mnBitsPerPixel;
-        if ( mnBitsPerPixel <= 8 )
+        if (mnBitsPerPixel <= 8)
             mnFilterType = 0;
         else
             mnFilterType = 4;
 
-        sal_uInt8 nColorType = 2;                   // colortype:
-                                                // bit 0 -> palette is used
-        if ( mpAccess->HasPalette() )           // bit 1 -> color is used
-            nColorType |= 1;                    // bit 2 -> alpha channel is used
+        sal_uInt8 nColorType = 2; // colortype:
+
+                                    // bit 0 -> palette is used
+        if (mpAccess->HasPalette()) // bit 1 -> color is used
+            nColorType |= 1;        // bit 2 -> alpha channel is used
         else
             nBitDepth /= 3;
 
-        if ( mpMaskAccess )
+        if (mpMaskAccess)
             nColorType |= 4;
 
-        ImplWriteChunk( nBitDepth );
-        ImplWriteChunk( nColorType );           // colortype
-        ImplWriteChunk((sal_uInt8) 0 );             // compression type
-        ImplWriteChunk((sal_uInt8) 0 );             // filter type - is not supported in this version
-        ImplWriteChunk((sal_uInt8) mnInterlaced );  // interlace type
+        ImplWriteChunk(nBitDepth);
+        ImplWriteChunk(nColorType); // colortype
+        ImplWriteChunk(static_cast<sal_uInt8>(0)); // compression type
+        ImplWriteChunk(static_cast<sal_uInt8>(0)); // filter type - is not supported in this version
+        ImplWriteChunk(static_cast<sal_uInt8>(mnInterlaced)); // interlace type
     }
     else
+    {
         mbStatus = false;
+    }
     return mbStatus;
 }
 
 void PNGWriterImpl::ImplWritePalette()
 {
     const sal_uLong nCount = mpAccess->GetPaletteEntryCount();
-    boost::scoped_array<sal_uInt8> pTempBuf(new sal_uInt8[ nCount*3 ]);
-    sal_uInt8*      pTmp = pTempBuf.get();
+    boost::scoped_array<sal_uInt8> pTempBuf(new sal_uInt8[nCount * 3]);
+    sal_uInt8* pTmp = pTempBuf.get();
 
-    ImplOpenChunk( PNGCHUNK_PLTE );
+    ImplOpenChunk(PNGCHUNK_PLTE);
 
     for ( sal_uInt16 i = 0; i < nCount; i++ )
     {
-        const BitmapColor& rColor = mpAccess->GetPaletteColor( i );
+        const BitmapColor& rColor = mpAccess->GetPaletteColor(i);
         *pTmp++ = rColor.GetRed();
         *pTmp++ = rColor.GetGreen();
         *pTmp++ = rColor.GetBlue();
     }
-    ImplWriteChunk( pTempBuf.get(), nCount*3 );
+    ImplWriteChunk(pTempBuf.get(), nCount * 3);
 }
 
-void PNGWriterImpl::ImplWriteTransparent ()
+void PNGWriterImpl::ImplWriteTransparent()
 {
-    const sal_uLong nTransIndex = mpAccess->GetBestPaletteIndex( BMP_COL_TRANS );
+    const sal_uLong nTransIndex = mpAccess->GetBestPaletteIndex(BMP_COL_TRANS);
 
-    ImplOpenChunk( PNGCHUNK_tRNS );
+    ImplOpenChunk(PNGCHUNK_tRNS);
 
-    for ( sal_uLong n = 0UL; n <= nTransIndex; n++ )
-        ImplWriteChunk( ( nTransIndex == n ) ? (sal_uInt8) 0x0 : (sal_uInt8) 0xff );
+    for (sal_uLong n = 0UL; n <= nTransIndex; n++)
+    {
+        ImplWriteChunk((nTransIndex == n) ? static_cast<sal_uInt8>(0x0) : static_cast<sal_uInt8>(0xff));
+    }
 }
 
-void PNGWriterImpl::ImplWritepHYs( const BitmapEx& rBmpEx )
+void PNGWriterImpl::ImplWritepHYs(const BitmapEx& rBmpEx)
 {
-    if ( rBmpEx.GetPrefMapMode() == MAP_100TH_MM )
+    if (rBmpEx.GetPrefMapMode() == MAP_100TH_MM)
     {
-        Size aPrefSize( rBmpEx.GetPrefSize() );
-        if ( aPrefSize.Width() && aPrefSize.Height() && mnWidth && mnHeight )
+        Size aPrefSize(rBmpEx.GetPrefSize());
+
+        if (aPrefSize.Width() && aPrefSize.Height() && mnWidth && mnHeight)
         {
-            ImplOpenChunk( PNGCHUNK_pHYs );
+            ImplOpenChunk(PNGCHUNK_pHYs);
             sal_uInt8 nMapUnit = 1;
-            sal_uInt32 nPrefSizeX = (sal_uInt32)( (double)100000.0 / ( (double)aPrefSize.Width() / mnWidth ) + 0.5 );
-            sal_uInt32 nPrefSizeY = (sal_uInt32)( (double)100000.0 / ( (double)aPrefSize.Height() / mnHeight ) + 0.5 );
-            ImplWriteChunk( nPrefSizeX );
-            ImplWriteChunk( nPrefSizeY );
-            ImplWriteChunk( nMapUnit );
+            sal_uInt32 nPrefSizeX = static_cast<sal_uInt32>(100000.0 / (static_cast<double>(aPrefSize.Width()) / mnWidth) + 0.5);
+            sal_uInt32 nPrefSizeY = static_cast<sal_uInt32>(100000.0 / (static_cast<double>(aPrefSize.Height()) / mnHeight) + 0.5);
+            ImplWriteChunk(nPrefSizeX);
+            ImplWriteChunk(nPrefSizeY);
+            ImplWriteChunk(nMapUnit);
         }
     }
 }
 
-void PNGWriterImpl::ImplWriteIDAT ()
+void PNGWriterImpl::ImplWriteIDAT()
 {
     mnDeflateInSize = mnBitsPerPixel;
 
-    if( mpMaskAccess )
+    if (mpMaskAccess)
         mnDeflateInSize += 8;
 
-    mnBBP = ( mnDeflateInSize + 7 ) >> 3;
+    mnBBP = (mnDeflateInSize + 7) >> 3;
 
     mnDeflateInSize = mnBBP * mnWidth + 1;
 
-    mpDeflateInBuf = new sal_uInt8[ mnDeflateInSize ];
+    mpDeflateInBuf = new sal_uInt8[mnDeflateInSize];
 
-    if ( mnFilterType )         // using filter type 4 we need memory for the scanline 3 times
+    if (mnFilterType) // using filter type 4 we need memory for the scanline 3 times
     {
-        mpPreviousScan = new sal_uInt8[ mnDeflateInSize ];
-        mpCurrentScan = new sal_uInt8[ mnDeflateInSize ];
+        mpPreviousScan = new sal_uInt8[mnDeflateInSize];
+        mpCurrentScan = new sal_uInt8[mnDeflateInSize];
         ImplClearFirstScanline();
     }
-    mpZCodec.BeginCompression( mnCompLevel, true );
-    mpZCodec.SetCRC( mnCRC );
+    mpZCodec.BeginCompression(mnCompLevel, true);
+    mpZCodec.SetCRC(mnCRC);
     SvMemoryStream aOStm;
-    if ( mnInterlaced == 0 )
+    if (mnInterlaced == 0)
     {
-        for ( sal_uLong nY = 0; nY < mnHeight; nY++ )
-            mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter( nY ) );
+        for (sal_uLong nY = 0; nY < mnHeight; nY++)
+        {
+            mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY));
+        }
     }
     else
     {
         // interlace mode
         sal_uLong nY;
-        for ( nY = 0; nY < mnHeight; nY+=8 )                                                // pass 1
-            mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 0, 8 ) );
+        for (nY = 0; nY < mnHeight; nY += 8) // pass 1
+        {
+            mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 8));
+        }
         ImplClearFirstScanline();
 
-        for ( nY = 0; nY < mnHeight; nY+=8 )                                                // pass 2
-            mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 4, 8 ) );
+        for (nY = 0; nY < mnHeight; nY += 8) // pass 2
+        {
+            mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 4, 8));
+        }
         ImplClearFirstScanline();
 
-        if ( mnHeight >= 5 )                                                                // pass 3
+        if (mnHeight >= 5) // pass 3
         {
-            for ( nY = 4; nY < mnHeight; nY+=8 )
-                mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 0, 4 ) );
+            for (nY = 4; nY < mnHeight; nY += 8)
+            {
+                mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 4));
+            }
             ImplClearFirstScanline();
         }
 
-        for ( nY = 0; nY < mnHeight; nY+=4 )                                                // pass 4
-            mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 2, 4 ) );
+        for (nY = 0; nY < mnHeight; nY += 4) // pass 4
+        {
+            mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 2, 4));
+        }
         ImplClearFirstScanline();
 
-        if ( mnHeight >= 3 )                                                                // pass 5
+        if (mnHeight >= 3) // pass 5
         {
-            for ( nY = 2; nY < mnHeight; nY+=4 )
-                mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 0, 2 ) );
+            for (nY = 2; nY < mnHeight; nY += 4)
+            {
+                mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 0, 2));
+            }
             ImplClearFirstScanline();
         }
 
-        for ( nY = 0; nY < mnHeight; nY+=2 )                                                // pass 6
-            mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 1, 2 ) );
+        for (nY = 0; nY < mnHeight; nY += 2) // pass 6
+        {
+            mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter(nY, 1, 2));
+        }
         ImplClearFirstScanline();
 
-        if ( mnHeight >= 2 )                                                                // pass 7
+        if (mnHeight >= 2) // pass 7
         {
-            for ( nY = 1; nY < mnHeight; nY+=2 )
-                mpZCodec.Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 0, 1 ) );
+            for (nY = 1; nY < mnHeight; nY += 2)
+            {
+                mpZCodec.Write(aOStm, mpDeflateInBuf, ImplGetFilter (nY, 0, 1));
+            }
         }
     }
     mpZCodec.EndCompression();
     mnCRC = mpZCodec.GetCRC();
 
-    if ( mnFilterType )         // using filter type 4 we need memory for the scanline 3 times
+    if (mnFilterType) // using filter type 4 we need memory for the scanline 3 times
     {
         delete[] mpCurrentScan;
         delete[] mpPreviousScan;
@@ -428,11 +470,11 @@ void PNGWriterImpl::ImplWriteIDAT ()
 
     sal_uInt32 nIDATSize = aOStm.Tell();
     sal_uInt32 nBytes, nBytesToWrite = nIDATSize;
-    while( nBytesToWrite )
+    while(nBytesToWrite)
     {
         nBytes = nBytesToWrite <= mnMaxChunkSize ? nBytesToWrite : mnMaxChunkSize;
-        ImplOpenChunk( PNGCHUNK_IDAT );
-        ImplWriteChunk( (unsigned char*)aOStm.GetData() + ( nIDATSize - nBytesToWrite ), nBytes );
+        ImplOpenChunk(PNGCHUNK_IDAT);
+        ImplWriteChunk((unsigned char*)aOStm.GetData() + (nIDATSize - nBytesToWrite), nBytes);
         nBytesToWrite -= nBytes;
     }
 }
@@ -441,58 +483,62 @@ void PNGWriterImpl::ImplWriteIDAT ()
 // appends to the currently used pass
 // the complete size of scanline will be returned - in interlace mode zero is possible!
 
-sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uLong nXAdd )
+sal_uLong PNGWriterImpl::ImplGetFilter (sal_uLong nY, sal_uLong nXStart, sal_uLong nXAdd)
 {
     sal_uInt8* pDest;
 
-    if ( mnFilterType )
+    if (mnFilterType)
         pDest = mpCurrentScan;
     else
         pDest = mpDeflateInBuf;
 
-    if ( nXStart < mnWidth )
+    if (nXStart < mnWidth)
     {
-        *pDest++ = mnFilterType;        // in this version the filter type is either 0 or 4
+        *pDest++ = mnFilterType; // in this version the filter type is either 0 or 4
 
-        if ( mpAccess->HasPalette() )   // alphachannel is not allowed by pictures including palette entries
+        if (mpAccess->HasPalette()) // alphachannel is not allowed by pictures including palette entries
         {
-            switch ( mnBitsPerPixel )
+            switch (mnBitsPerPixel)
             {
-                case( 1 ):
+                case 1:
                 {
                     sal_uLong nX, nXIndex;
-                    for ( nX = nXStart, nXIndex = 0; nX < mnWidth; nX+=nXAdd, nXIndex++ )
+                    for (nX = nXStart, nXIndex = 0; nX < mnWidth; nX += nXAdd, nXIndex++)
                     {
-                        sal_uLong nShift = ( nXIndex & 7 ) ^ 7;
-                        if ( nShift == 7)
-                            *pDest = mpAccess->GetPixelIndex( nY, nX ) << nShift;
-                        else if  ( nShift == 0 )
-                            *pDest++ |= mpAccess->GetPixelIndex( nY, nX ) << nShift;
+                        sal_uLong nShift = (nXIndex & 7) ^ 7;
+                        if (nShift == 7)
+                            *pDest = mpAccess->GetPixelIndex(nY, nX) << nShift;
+                        else if  (nShift == 0)
+                            *pDest++ |= mpAccess->GetPixelIndex(nY, nX) << nShift;
                         else
-                            *pDest |= mpAccess->GetPixelIndex( nY, nX ) << nShift;
+                            *pDest |= mpAccess->GetPixelIndex(nY, nX) << nShift;
                     }
-                    if ( ( nXIndex & 7 ) != 0 ) pDest++;    // byte is not completely used, so the
-                }                                           // bufferpointer is to correct
+                    if ( (nXIndex & 7) != 0 )
+                        pDest++;    // byte is not completely used, so the bufferpointer is to correct
+                }
                 break;
 
-                case( 4 ):
+                case 4:
                 {
                     sal_uLong nX, nXIndex;
-                    for ( nX = nXStart, nXIndex = 0; nX < mnWidth; nX+= nXAdd, nXIndex++ )
+                    for (nX = nXStart, nXIndex = 0; nX < mnWidth; nX += nXAdd, nXIndex++)
                     {
-                        if( nXIndex & 1 )
-                            *pDest++ |= mpAccess->GetPixelIndex( nY, nX );
+                        if(nXIndex & 1)
+                            *pDest++ |= mpAccess->GetPixelIndex(nY, nX);
                         else
-                            *pDest = mpAccess->GetPixelIndex( nY, nX ) << 4;
+                            *pDest = mpAccess->GetPixelIndex(nY, nX) << 4;
                     }
-                    if ( nXIndex & 1 ) pDest++;
+                    if (nXIndex & 1)
+                        pDest++;
                 }
                 break;
 
-                case( 8 ):
+                case 8:
                 {
-                    for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
+                    for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
+                    {
                         *pDest++ = mpAccess->GetPixelIndex( nY, nX );
+                    }
                 }
                 break;
 
@@ -503,31 +549,31 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
         }
         else
         {
-            if ( mpMaskAccess )             // mpMaskAccess != NULL -> alphachannel is to create
+            if (mpMaskAccess) // mpMaskAccess != NULL -> alphachannel is to create
             {
-                if ( mbTrueAlpha )
+                if (mbTrueAlpha)
                 {
-                    for ( sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd )
+                    for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
                     {
-                        const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
+                        const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
                         *pDest++ = rColor.GetRed();
                         *pDest++ = rColor.GetGreen();
                         *pDest++ = rColor.GetBlue();
-                        *pDest++ = 255 - mpMaskAccess->GetPixelIndex( nY, nX );
+                        *pDest++ = 255 - mpMaskAccess->GetPixelIndex(nY, nX);
                     }
                 }
                 else
                 {
-                    const BitmapColor aTrans( mpMaskAccess->GetBestMatchingColor( Color( COL_WHITE ) ) );
+                    const BitmapColor aTrans(mpMaskAccess->GetBestMatchingColor(Color(COL_WHITE)));
 
-                    for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
+                    for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
                     {
-                        const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
+                        const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
                         *pDest++ = rColor.GetRed();
                         *pDest++ = rColor.GetGreen();
                         *pDest++ = rColor.GetBlue();
 
-                        if( mpMaskAccess->GetPixel( nY, nX ) == aTrans )
+                        if(mpMaskAccess->GetPixel(nY, nX) == aTrans)
                             *pDest++ = 0;
                         else
                             *pDest++ = 0xff;
@@ -536,9 +582,9 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
             }
             else
             {
-                for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
+                for (sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd)
                 {
-                    const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
+                    const BitmapColor& rColor = mpAccess->GetPixel(nY, nX);
                     *pDest++ = rColor.GetRed();
                     *pDest++ = rColor.GetGreen();
                     *pDest++ = rColor.GetBlue();
@@ -547,110 +593,121 @@ sal_uLong PNGWriterImpl::ImplGetFilter ( sal_uLong nY, sal_uLong nXStart, sal_uL
         }
     }
     // filter type4 ( PAETH ) will be used only for 24bit graphics
-    if ( mnFilterType )
+    if (mnFilterType)
     {
         mnDeflateInSize = pDest - mpCurrentScan;
         pDest = mpDeflateInBuf;
-        *pDest++ = 4;                                   // filter type
+        *pDest++ = 4; // filter type
 
         sal_uLong na, nb, nc;
         long  np, npa, npb, npc;
 
-        sal_uInt8* p1 = mpCurrentScan + 1;                  // Current Pixel
-        sal_uInt8* p2 = p1 - mnBBP;                         // left pixel
-        sal_uInt8* p3 = mpPreviousScan;                     // upper pixel
-        sal_uInt8* p4 = p3 - mnBBP;                         // upperleft Pixel;
+        sal_uInt8* p1 = mpCurrentScan + 1; // Current Pixel
+        sal_uInt8* p2 = p1 - mnBBP;        // left pixel
+        sal_uInt8* p3 = mpPreviousScan;    // upper pixel
+        sal_uInt8* p4 = p3 - mnBBP;        // upperleft Pixel;
 
-        while ( pDest < mpDeflateInBuf + mnDeflateInSize )
+        while (pDest < mpDeflateInBuf + mnDeflateInSize)
         {
             nb = *p3++;
-            if ( p2 >= mpCurrentScan + 1 )
+            if (p2 >= mpCurrentScan + 1)
             {
                 na = *p2;
                 nc = *p4;
             }
             else
+            {
                 na = nc = 0;
+            }
 
             np = na + nb;
             np -= nc;
             npa = np - na;
             npb = np - nb;
             npc = np - nc;
-            if ( npa < 0 )
+
+            if (npa < 0)
                 npa =-npa;
-            if ( npb < 0 )
+            if (npb < 0)
                 npb =-npb;
-            if ( npc < 0 )
+            if (npc < 0)
                 npc =-npc;
-            if ( ( npa <= npb ) && ( npa <= npc ) ) *pDest++ = *p1++ - (sal_uInt8)na;
-            else if ( npb <= npc ) *pDest++ = *p1++ - (sal_uInt8)nb;
-            else *pDest++ = *p1++ - (sal_uInt8)nc;
+
+            if (npa <= npb && npa <= npc)
+                *pDest++ = *p1++ - static_cast<sal_uInt8>(na);
+            else if ( npb <= npc )
+                *pDest++ = *p1++ - static_cast<sal_uInt8>(nb);
+            else
+                *pDest++ = *p1++ - static_cast<sal_uInt8>(nc);
+
             p4++;
             p2++;
         }
-        for ( long i = 0; i < (long)( mnDeflateInSize - 1 ); i++ )
-            mpPreviousScan[ i ] = mpCurrentScan[ i + 1 ];
+        for (long i = 0; i < static_cast<long>(mnDeflateInSize - 1); i++)
+        {
+            mpPreviousScan[i] = mpCurrentScan[i + 1];
+        }
     }
     else
+    {
         mnDeflateInSize = pDest - mpDeflateInBuf;
+    }
     return mnDeflateInSize;
 }
 
 void PNGWriterImpl::ImplClearFirstScanline()
 {
-    if ( mnFilterType )
-        memset( mpPreviousScan, 0, mnDeflateInSize );
+    if (mnFilterType)
+        memset(mpPreviousScan, 0, mnDeflateInSize);
 }
 
-void PNGWriterImpl::ImplOpenChunk ( sal_uLong nChunkType )
+void PNGWriterImpl::ImplOpenChunk (sal_uLong nChunkType)
 {
-    maChunkSeq.resize( maChunkSeq.size() + 1 );
+    maChunkSeq.resize(maChunkSeq.size() + 1);
     maChunkSeq.back().nType = nChunkType;
 }
 
-void PNGWriterImpl::ImplWriteChunk ( sal_uInt8 nSource )
+void PNGWriterImpl::ImplWriteChunk (sal_uInt8 nSource)
 {
-    maChunkSeq.back().aData.push_back( nSource );
+    maChunkSeq.back().aData.push_back(nSource);
 }
 
-void PNGWriterImpl::ImplWriteChunk ( sal_uInt32 nSource )
+void PNGWriterImpl::ImplWriteChunk (sal_uInt32 nSource)
 {
     vcl::PNGWriter::ChunkData& rChunkData = maChunkSeq.back();
-    rChunkData.aData.push_back( (sal_uInt8)( nSource >> 24 ) );
-    rChunkData.aData.push_back( (sal_uInt8)( nSource >> 16 ) );
-    rChunkData.aData.push_back( (sal_uInt8)( nSource >> 8 ) );
-    rChunkData.aData.push_back( (sal_uInt8)( nSource ) );
+    rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 24));
+    rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 16));
+    rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource >> 8));
+    rChunkData.aData.push_back(static_cast<sal_uInt8>(nSource));
 }
 
-void PNGWriterImpl::ImplWriteChunk ( unsigned char* pSource, sal_uInt32 nDatSize )
+void PNGWriterImpl::ImplWriteChunk (unsigned char* pSource, sal_uInt32 nDatSize)
 {
-    if ( nDatSize )
+    if (nDatSize)
     {
         vcl::PNGWriter::ChunkData& rChunkData = maChunkSeq.back();
         sal_uInt32 nSize = rChunkData.aData.size();
-        rChunkData.aData.resize( nSize + nDatSize );
-        memcpy( &rChunkData.aData[ nSize ], pSource, nDatSize );
+        rChunkData.aData.resize(nSize + nDatSize);
+        memcpy(&rChunkData.aData[nSize], pSource, nDatSize);
     }
 }
 
-PNGWriter::PNGWriter( const BitmapEx& rBmpEx,
-    const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData ) :
-    mpImpl( new ::vcl::PNGWriterImpl( rBmpEx, pFilterData ) )
+PNGWriter::PNGWriter(const BitmapEx& rBmpEx,
+                     const css::uno::Sequence<css::beans::PropertyValue>* pFilterData)
+    : mpImpl(new vcl::PNGWriterImpl(rBmpEx, pFilterData))
 {
 }
 
 PNGWriter::~PNGWriter()
 {
-    delete mpImpl;
 }
 
-bool PNGWriter::Write( SvStream& rIStm )
+bool PNGWriter::Write(SvStream& rStream)
 {
-    return mpImpl->Write( rIStm );
+    return mpImpl->Write(rStream);
 }
 
-std::vector< vcl::PNGWriter::ChunkData >& PNGWriter::GetChunks()
+std::vector<vcl::PNGWriter::ChunkData>& PNGWriter::GetChunks()
 {
     return mpImpl->GetChunks();
 }