739 lines
25 KiB
C++
739 lines
25 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_vcl.hxx"
|
|
|
|
#include <vcl/pngwrite.hxx>
|
|
|
|
#include <cmath>
|
|
#include <limits>
|
|
#include <rtl/crc.h>
|
|
#include <rtl/memory.h>
|
|
#include <rtl/alloc.h>
|
|
#include <tools/zcodec.hxx>
|
|
#include <tools/stream.hxx>
|
|
#include <vcl/bmpacc.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <vcl/alpha.hxx>
|
|
#include <osl/endian.h>
|
|
|
|
// -----------
|
|
// - Defines -
|
|
// -----------
|
|
|
|
#define PNG_DEF_COMPRESSION 6
|
|
|
|
#define PNGCHUNK_IHDR 0x49484452
|
|
#define PNGCHUNK_PLTE 0x504c5445
|
|
#define PNGCHUNK_IDAT 0x49444154
|
|
#define PNGCHUNK_IEND 0x49454e44
|
|
#define PNGCHUNK_bKGD 0x624b4744
|
|
#define PNGCHUNK_cHRM 0x6348524d
|
|
#define PNGCHUNK_gAMA 0x67414d41
|
|
#define PNGCHUNK_hIST 0x68495354
|
|
#define PNGCHUNK_pHYs 0x70485973
|
|
#define PNGCHUNK_sBIT 0x73425420
|
|
#define PNGCHUNK_tIME 0x74494d45
|
|
#define PNGCHUNK_tEXt 0x74455874
|
|
#define PNGCHUNK_tRNS 0x74524e53
|
|
#define PNGCHUNK_zTXt 0x7a545874
|
|
|
|
namespace vcl
|
|
{
|
|
// -----------------
|
|
// - PNGWriterImplImpl -
|
|
// -----------------
|
|
|
|
class PNGWriterImpl
|
|
{
|
|
public:
|
|
|
|
PNGWriterImpl( const BitmapEx& BmpEx,
|
|
const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData = NULL );
|
|
~PNGWriterImpl();
|
|
|
|
sal_Bool Write( SvStream& rOStm );
|
|
|
|
std::vector< vcl::PNGWriter::ChunkData >& GetChunks();
|
|
|
|
private:
|
|
|
|
std::vector< vcl::PNGWriter::ChunkData > maChunkSeq;
|
|
|
|
sal_Int32 mnCompLevel;
|
|
sal_Int32 mnInterlaced;
|
|
sal_uInt32 mnMaxChunkSize;
|
|
sal_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 )
|
|
sal_Bool mbTrueAlpha;
|
|
sal_uLong mnCRC;
|
|
long mnChunkDatSize;
|
|
sal_uLong mnLastPercent;
|
|
|
|
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();
|
|
sal_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 );
|
|
void ImplCloseChunk( void ) const;
|
|
};
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
PNGWriterImpl::PNGWriterImpl( const BitmapEx& rBmpEx,
|
|
const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >* pFilterData ) :
|
|
mnCompLevel ( PNG_DEF_COMPRESSION ),
|
|
mbStatus ( sal_True ),
|
|
mpAccess ( NULL ),
|
|
mpMaskAccess ( NULL ),
|
|
mpZCodec ( new ZCodec( DEFAULT_IN_BUFSIZE, DEFAULT_OUT_BUFSIZE, MAX_MEM_USAGE ) ),
|
|
mnCRC(0UL),
|
|
mnLastPercent ( 0UL )
|
|
{
|
|
if ( !rBmpEx.IsEmpty() )
|
|
{
|
|
Bitmap aBmp( rBmpEx.GetBitmap() );
|
|
|
|
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;
|
|
|
|
if ( pFilterData )
|
|
{
|
|
sal_Int32 i = 0;
|
|
for ( i = 0; i < pFilterData->getLength(); i++ )
|
|
{
|
|
if ( (*pFilterData)[ i ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Compression" ) ) )
|
|
(*pFilterData)[ i ].Value >>= mnCompLevel;
|
|
else if ( (*pFilterData)[ i ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Interlaced" ) ) )
|
|
(*pFilterData)[ i ].Value >>= mnInterlaced;
|
|
else if ( (*pFilterData)[ i ].Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "MaxChunkSize" ) ) )
|
|
{
|
|
sal_Int32 nVal = 0;
|
|
if ( (*pFilterData)[ i ].Value >>= nVal )
|
|
mnMaxChunkSize = (sal_uInt32)nVal;
|
|
}
|
|
}
|
|
}
|
|
mnBitsPerPixel = (sal_uInt8)aBmp.GetBitCount();
|
|
|
|
if( rBmpEx.IsTransparent() )
|
|
{
|
|
if ( mnBitsPerPixel <= 8 && rBmpEx.IsAlpha() )
|
|
{
|
|
aBmp.Convert( BMP_CONVERSION_24BIT );
|
|
mnBitsPerPixel = 24;
|
|
}
|
|
|
|
if ( mnBitsPerPixel <= 8 ) // transparent palette
|
|
{
|
|
aBmp.Convert( BMP_CONVERSION_8BIT_TRANS );
|
|
aBmp.Replace( rBmpEx.GetMask(), BMP_COL_TRANS );
|
|
mnBitsPerPixel = 8;
|
|
mpAccess = aBmp.AcquireReadAccess();
|
|
if ( mpAccess )
|
|
{
|
|
if ( ImplWriteHeader() )
|
|
{
|
|
ImplWritepHYs( rBmpEx );
|
|
ImplWritePalette();
|
|
ImplWriteTransparent();
|
|
ImplWriteIDAT();
|
|
}
|
|
aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
}
|
|
else
|
|
{
|
|
mpAccess = aBmp.AcquireReadAccess(); // sal_True RGB with alphachannel
|
|
if( mpAccess )
|
|
{
|
|
if ( ( mbTrueAlpha = rBmpEx.IsAlpha() ) != sal_False )
|
|
{
|
|
AlphaMask aMask( rBmpEx.GetAlpha() );
|
|
mpMaskAccess = aMask.AcquireReadAccess();
|
|
if ( mpMaskAccess )
|
|
{
|
|
if ( ImplWriteHeader() )
|
|
{
|
|
ImplWritepHYs( rBmpEx );
|
|
ImplWriteIDAT();
|
|
}
|
|
aMask.ReleaseAccess( mpMaskAccess ), mpMaskAccess = 0;
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
}
|
|
else
|
|
{
|
|
Bitmap aMask( rBmpEx.GetMask() );
|
|
mpMaskAccess = aMask.AcquireReadAccess();
|
|
if( mpMaskAccess )
|
|
{
|
|
if ( ImplWriteHeader() )
|
|
{
|
|
ImplWritepHYs( rBmpEx );
|
|
ImplWriteIDAT();
|
|
}
|
|
aMask.ReleaseAccess( mpMaskAccess ), mpMaskAccess = 0;
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
}
|
|
aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mpAccess = aBmp.AcquireReadAccess(); // palette + RGB without alphachannel
|
|
if( mpAccess )
|
|
{
|
|
if ( ImplWriteHeader() )
|
|
{
|
|
ImplWritepHYs( rBmpEx );
|
|
if( mpAccess->HasPalette() )
|
|
ImplWritePalette();
|
|
|
|
ImplWriteIDAT();
|
|
}
|
|
aBmp.ReleaseAccess( mpAccess ), mpAccess = 0;
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
}
|
|
if ( mbStatus )
|
|
{
|
|
ImplOpenChunk( PNGCHUNK_IEND ); // create an IEND chunk
|
|
ImplCloseChunk();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
PNGWriterImpl::~PNGWriterImpl()
|
|
{
|
|
delete mpZCodec;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
sal_Bool PNGWriterImpl::Write( SvStream& rOStm )
|
|
{
|
|
/* png signature is always an array of 8 bytes */
|
|
sal_uInt16 nOldMode = rOStm.GetNumberFormatInt();
|
|
rOStm.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
|
|
rOStm << static_cast<sal_uInt32>(0x89504e47);
|
|
rOStm << static_cast<sal_uInt32>(0x0d0a1a0a);
|
|
|
|
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 = SWAPLONG( nType );
|
|
#endif
|
|
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 << nDataSize
|
|
<< aBeg->nType;
|
|
if ( nDataSize )
|
|
rOStm.Write( &aBeg->aData[ 0 ], nDataSize );
|
|
rOStm << nCRC;
|
|
aBeg++;
|
|
}
|
|
rOStm.SetNumberFormatInt( nOldMode );
|
|
return mbStatus;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
std::vector< vcl::PNGWriter::ChunkData >& PNGWriterImpl::GetChunks()
|
|
{
|
|
return maChunkSeq;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
sal_Bool PNGWriterImpl::ImplWriteHeader()
|
|
{
|
|
ImplOpenChunk(PNGCHUNK_IHDR);
|
|
ImplWriteChunk( sal_uInt32( mnWidth = mpAccess->Width() ) );
|
|
ImplWriteChunk( sal_uInt32( mnHeight = mpAccess->Height() ) );
|
|
|
|
if ( mnWidth && mnHeight && mnBitsPerPixel && mbStatus )
|
|
{
|
|
sal_uInt8 nBitDepth = mnBitsPerPixel;
|
|
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
|
|
else
|
|
nBitDepth /= 3;
|
|
|
|
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
|
|
ImplCloseChunk();
|
|
}
|
|
else
|
|
mbStatus = sal_False;
|
|
return mbStatus;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplWritePalette()
|
|
{
|
|
const sal_uLong nCount = mpAccess->GetPaletteEntryCount();
|
|
sal_uInt8* pTempBuf = new sal_uInt8[ nCount*3 ];
|
|
sal_uInt8* pTmp = pTempBuf;
|
|
|
|
ImplOpenChunk( PNGCHUNK_PLTE );
|
|
|
|
for ( sal_uInt16 i = 0; i < nCount; i++ )
|
|
{
|
|
const BitmapColor& rColor = mpAccess->GetPaletteColor( i );
|
|
*pTmp++ = rColor.GetRed();
|
|
*pTmp++ = rColor.GetGreen();
|
|
*pTmp++ = rColor.GetBlue();
|
|
}
|
|
ImplWriteChunk( pTempBuf, nCount*3 );
|
|
ImplCloseChunk();
|
|
delete[] pTempBuf;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplWriteTransparent ()
|
|
{
|
|
const sal_uLong nTransIndex = mpAccess->GetBestMatchingColor( BMP_COL_TRANS );
|
|
|
|
ImplOpenChunk( PNGCHUNK_tRNS );
|
|
|
|
for ( sal_uLong n = 0UL; n <= nTransIndex; n++ )
|
|
ImplWriteChunk( ( nTransIndex == n ) ? (sal_uInt8) 0x0 : (sal_uInt8) 0xff );
|
|
|
|
ImplCloseChunk();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplWritepHYs( const BitmapEx& rBmpEx )
|
|
{
|
|
if ( rBmpEx.GetPrefMapMode() == MAP_100TH_MM )
|
|
{
|
|
Size aPrefSize( rBmpEx.GetPrefSize() );
|
|
if ( aPrefSize.Width() && aPrefSize.Height() )
|
|
{
|
|
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 );
|
|
ImplCloseChunk();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplWriteIDAT ()
|
|
{
|
|
mnDeflateInSize = mnBitsPerPixel;
|
|
|
|
if( mpMaskAccess )
|
|
mnDeflateInSize += 8;
|
|
|
|
mnBBP = ( mnDeflateInSize + 7 ) >> 3;
|
|
|
|
mnDeflateInSize = mnBBP * mnWidth + 1;
|
|
|
|
mpDeflateInBuf = new sal_uInt8[ mnDeflateInSize ];
|
|
|
|
if ( mnFilterType ) // using filter type 4 we need memory for the scanline 3 times
|
|
{
|
|
mpPreviousScan = new sal_uInt8[ mnDeflateInSize ];
|
|
mpCurrentScan = new sal_uInt8[ mnDeflateInSize ];
|
|
ImplClearFirstScanline();
|
|
}
|
|
mpZCodec->BeginCompression( ZCODEC_PNG_DEFAULT + mnCompLevel );
|
|
mpZCodec->SetCRC( mnCRC );
|
|
SvMemoryStream aOStm;
|
|
if ( mnInterlaced == 0 )
|
|
{
|
|
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 ) );
|
|
ImplClearFirstScanline();
|
|
|
|
for ( nY = 0; nY < mnHeight; nY+=8 ) // pass 2
|
|
mpZCodec->Write( aOStm, mpDeflateInBuf, ImplGetFilter ( nY, 4, 8 ) );
|
|
ImplClearFirstScanline();
|
|
|
|
if ( mnHeight >= 5 ) // pass 3
|
|
{
|
|
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 ) );
|
|
ImplClearFirstScanline();
|
|
|
|
if ( mnHeight >= 3 ) // pass 5
|
|
{
|
|
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 ) );
|
|
ImplClearFirstScanline();
|
|
|
|
if ( mnHeight >= 2 ) // pass 7
|
|
{
|
|
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
|
|
{
|
|
delete[] mpCurrentScan;
|
|
delete[] mpPreviousScan;
|
|
}
|
|
delete[] mpDeflateInBuf;
|
|
|
|
sal_uInt32 nIDATSize = aOStm.Tell();
|
|
sal_uInt32 nBytes, nBytesToWrite = nIDATSize;
|
|
while( nBytesToWrite )
|
|
{
|
|
nBytes = nBytesToWrite <= mnMaxChunkSize ? nBytesToWrite : mnMaxChunkSize;
|
|
ImplOpenChunk( PNGCHUNK_IDAT );
|
|
ImplWriteChunk( (unsigned char*)aOStm.GetData() + ( nIDATSize - nBytesToWrite ), nBytes );
|
|
ImplCloseChunk();
|
|
nBytesToWrite -= nBytes;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------------
|
|
// ImplGetFilter writes the complete Scanline (nY) - in interlace mode the parameter nXStart and nXAdd
|
|
// 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_uInt8* pDest;
|
|
|
|
if ( mnFilterType )
|
|
pDest = mpCurrentScan;
|
|
else
|
|
pDest = mpDeflateInBuf;
|
|
|
|
if ( nXStart < mnWidth )
|
|
{
|
|
*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
|
|
{
|
|
switch ( mnBitsPerPixel )
|
|
{
|
|
case( 1 ):
|
|
{
|
|
sal_uLong nX, nXIndex;
|
|
for ( nX = nXStart, nXIndex = 0; nX < mnWidth; nX+=nXAdd, nXIndex++ )
|
|
{
|
|
sal_uLong nShift = ( nXIndex & 7 ) ^ 7;
|
|
if ( nShift == 7)
|
|
*pDest = (sal_uInt8)(mpAccess->GetPixel( nY, nX ) << nShift);
|
|
else if ( nShift == 0 )
|
|
*pDest++ |= (sal_uInt8) mpAccess->GetPixel( nY, nX ) << nShift;
|
|
else
|
|
*pDest |= (sal_uInt8) mpAccess->GetPixel( nY, nX ) << nShift;
|
|
}
|
|
if ( ( nXIndex & 7 ) != 0 ) pDest++; // byte is not completely used, so the
|
|
} // bufferpointer is to correct
|
|
break;
|
|
|
|
case( 4 ):
|
|
{
|
|
sal_uLong nX, nXIndex;
|
|
for ( nX = nXStart, nXIndex = 0; nX < mnWidth; nX+= nXAdd, nXIndex++ )
|
|
{
|
|
if( nXIndex & 1 )
|
|
*pDest++ |= (sal_uInt8) mpAccess->GetPixel( nY, nX );
|
|
else
|
|
*pDest = (sal_uInt8) mpAccess->GetPixel( nY, nX ) << 4;
|
|
}
|
|
if ( nXIndex & 1 ) pDest++;
|
|
}
|
|
break;
|
|
|
|
case( 8 ):
|
|
{
|
|
for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
|
|
*pDest++ = mpAccess->GetPixel( nY, nX );
|
|
}
|
|
break;
|
|
|
|
default :
|
|
mbStatus = sal_False;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( mpMaskAccess ) // mpMaskAccess != NULL -> alphachannel is to create
|
|
{
|
|
if ( mbTrueAlpha )
|
|
{
|
|
for ( sal_uLong nX = nXStart; nX < mnWidth; nX += nXAdd )
|
|
{
|
|
const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
|
|
*pDest++ = rColor.GetRed();
|
|
*pDest++ = rColor.GetGreen();
|
|
*pDest++ = rColor.GetBlue();
|
|
*pDest++ = 255 - mpMaskAccess->GetPixel( nY, nX );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const BitmapColor aTrans( mpMaskAccess->GetBestMatchingColor( Color( COL_WHITE ) ) );
|
|
|
|
for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
|
|
{
|
|
const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
|
|
*pDest++ = rColor.GetRed();
|
|
*pDest++ = rColor.GetGreen();
|
|
*pDest++ = rColor.GetBlue();
|
|
|
|
if( mpMaskAccess->GetPixel( nY, nX ) == aTrans )
|
|
*pDest++ = 0;
|
|
else
|
|
*pDest++ = 0xff;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( sal_uLong nX = nXStart; nX < mnWidth; nX+=nXAdd )
|
|
{
|
|
const BitmapColor& rColor = mpAccess->GetPixel( nY, nX );
|
|
*pDest++ = rColor.GetRed();
|
|
*pDest++ = rColor.GetGreen();
|
|
*pDest++ = rColor.GetBlue();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// filter type4 ( PAETH ) will be used only for 24bit graphics
|
|
if ( mnFilterType )
|
|
{
|
|
mnDeflateInSize = pDest - mpCurrentScan;
|
|
pDest = mpDeflateInBuf;
|
|
*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;
|
|
|
|
while ( pDest < mpDeflateInBuf + mnDeflateInSize )
|
|
{
|
|
nb = *p3++;
|
|
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 )
|
|
npa =-npa;
|
|
if ( npb < 0 )
|
|
npb =-npb;
|
|
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;
|
|
p4++;
|
|
p2++;
|
|
}
|
|
for ( long i = 0; i < (long)( mnDeflateInSize - 1 ); i++ )
|
|
mpPreviousScan[ i ] = mpCurrentScan[ i + 1 ];
|
|
}
|
|
else
|
|
mnDeflateInSize = pDest - mpDeflateInBuf;
|
|
return ( mnDeflateInSize );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplClearFirstScanline()
|
|
{
|
|
if ( mnFilterType )
|
|
rtl_zeroMemory( mpPreviousScan, mnDeflateInSize );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplOpenChunk ( sal_uLong nChunkType )
|
|
{
|
|
maChunkSeq.resize( maChunkSeq.size() + 1 );
|
|
maChunkSeq.back().nType = nChunkType;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void PNGWriterImpl::ImplWriteChunk ( sal_uInt8 nSource )
|
|
{
|
|
maChunkSeq.back().aData.push_back( 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 ) );
|
|
}
|
|
|
|
void PNGWriterImpl::ImplWriteChunk ( unsigned char* pSource, sal_uInt32 nDatSize )
|
|
{
|
|
if ( nDatSize )
|
|
{
|
|
vcl::PNGWriter::ChunkData& rChunkData = maChunkSeq.back();
|
|
sal_uInt32 nSize = rChunkData.aData.size();
|
|
rChunkData.aData.resize( nSize + nDatSize );
|
|
rtl_copyMemory( &rChunkData.aData[ nSize ], pSource, nDatSize );
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
// nothing to do
|
|
void PNGWriterImpl::ImplCloseChunk ( void ) const
|
|
{
|
|
}
|
|
|
|
// -------------
|
|
// - PNGWriter -
|
|
// -------------
|
|
|
|
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()
|
|
{
|
|
delete mpImpl;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
sal_Bool PNGWriter::Write( SvStream& rIStm )
|
|
{
|
|
return mpImpl->Write( rIStm );
|
|
}
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
std::vector< vcl::PNGWriter::ChunkData >& PNGWriter::GetChunks()
|
|
{
|
|
return mpImpl->GetChunks();
|
|
}
|
|
|
|
} // namespace vcl
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|