AOO410/main/filter/source/graphicfilter/ipsd/ipsd.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_filter.hxx"

 #include <vcl/graph.hxx>
 #include <vcl/bmpacc.hxx>
 #include <svtools/fltcall.hxx>

 //============================ PSDReader ==================================

 #define	PSD_BITMAP			0
 #define PSD_GRAYSCALE 		1
 #define PSD_INDEXED			2
 #define PSD_RGB				3
 #define PSD_CMYK			4
 #define PSD_MULTICHANNEL	7
 #define PSD_DUOTONE			8
 #define PSD_LAB				9

 typedef struct
 {
 	sal_uInt32	nSignature;
 	sal_uInt16	nVersion;
 	sal_uInt32	nPad1;
 	sal_uInt16	nPad2;
 	sal_uInt16	nChannels;
 	sal_uInt32	nRows;
 	sal_uInt32	nColumns;
 	sal_uInt16	nDepth;
 	sal_uInt16	nMode;

 } PSDFileHeader;

 class PSDReader {

 private:

 	SvStream*			mpPSD;			// Die einzulesende PSD-Datei
 	PSDFileHeader*		mpFileHeader;

     sal_uInt32          mnXResFixed;
     sal_uInt32          mnYResFixed;

 	sal_Bool            mbStatus;
 	sal_Bool            mbTransparent;

 	Bitmap				maBmp;
 	Bitmap				maMaskBmp;
 	BitmapReadAccess*	mpReadAcc;
 	BitmapWriteAccess*	mpWriteAcc;
 	BitmapWriteAccess*	mpMaskWriteAcc;
 	sal_uInt16				mnDestBitDepth;
 	sal_Bool				mbCompression;	// RLE decoding
 	sal_uInt8*				mpPalette;

 	sal_Bool				ImplReadBody();
 	sal_Bool				ImplReadHeader();

 public:
 						PSDReader();
 						~PSDReader();
 	sal_Bool				ReadPSD( SvStream & rPSD, Graphic & rGraphic );
 };

 //=================== Methoden von PSDReader ==============================

 PSDReader::PSDReader() :
 	mpFileHeader	( NULL ),
     mnXResFixed     ( 0 ),
     mnYResFixed     ( 0 ),
 	mbStatus		( sal_True ),
 	mbTransparent	( sal_False ),
 	mpReadAcc		( NULL ),
 	mpWriteAcc		( NULL ),
 	mpMaskWriteAcc	( NULL ),
 	mpPalette		( NULL )
 {
 }

 PSDReader::~PSDReader()
 {
 	delete[] mpPalette;
 	delete mpFileHeader;
 }

 // ------------------------------------------------------------------------

 sal_Bool PSDReader::ReadPSD( SvStream & rPSD, Graphic & rGraphic )
 {
 	if ( rPSD.GetError() )
 		return sal_False;

 	mpPSD = &rPSD;
 	mpPSD->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );

 	// Kopf einlesen:

 	if ( ImplReadHeader() == sal_False )
 		return sal_False;

     Size aBitmapSize( mpFileHeader->nColumns, mpFileHeader->nRows );
 	maBmp = Bitmap( aBitmapSize, mnDestBitDepth );
 	if ( ( mpWriteAcc = maBmp.AcquireWriteAccess() ) == NULL )
 		mbStatus = sal_False;
 	if ( ( mpReadAcc = maBmp.AcquireReadAccess() ) == NULL )
 		mbStatus = sal_False;
 	if ( mbTransparent && mbStatus )
 	{
 		maMaskBmp = Bitmap( aBitmapSize, 1 );
 		if ( ( mpMaskWriteAcc = maMaskBmp.AcquireWriteAccess() ) == NULL )
 			mbStatus = sal_False;
 	}
 	if ( mpPalette && mbStatus )
 	{
 		mpWriteAcc->SetPaletteEntryCount( 256 );
 		for ( sal_uInt16 i = 0; i < 256; i++ )
 		{
 			mpWriteAcc->SetPaletteColor( i, Color( mpPalette[ i ], mpPalette[ i + 256 ], mpPalette[ i + 512 ] ) );
 		}
 	}
 	// Bitmap-Daten einlesen
 	if ( mbStatus && ImplReadBody() )
 	{
 		if ( mbTransparent )
 			rGraphic = Graphic( BitmapEx( maBmp, maMaskBmp ) );
 		else
 			rGraphic = maBmp;

         if ( mnXResFixed && mnYResFixed )
         {
             Point       aEmptyPoint;
 	        Fraction	aFractX( 1, mnXResFixed >> 16 );
 	        Fraction	aFractY( 1, mnYResFixed >> 16 );
 	        MapMode		aMapMode( MAP_INCH, aEmptyPoint, aFractX, aFractY );
 	        Size		aPrefSize = OutputDevice::LogicToLogic( aBitmapSize, aMapMode, MAP_100TH_MM );
             rGraphic.SetPrefSize( aPrefSize );
             rGraphic.SetPrefMapMode( MapMode( MAP_100TH_MM ) );
         }
 	}
 	else
 		mbStatus = sal_False;
 	if ( mpWriteAcc )
 		maBmp.ReleaseAccess( mpWriteAcc );
 	if ( mpReadAcc )
 		maBmp.ReleaseAccess( mpReadAcc );
 	if ( mpMaskWriteAcc )
 		maMaskBmp.ReleaseAccess( mpMaskWriteAcc );
 	return mbStatus;
 }

 // ------------------------------------------------------------------------

 sal_Bool PSDReader::ImplReadHeader()
 {
 	sal_uInt16	nCompression;
 	sal_uInt32	nColorLength, nResourceLength, nLayerMaskLength;

 	mpFileHeader = new PSDFileHeader;

 	if ( !mpFileHeader )
 		return sal_False;

 	*mpPSD >> mpFileHeader->nSignature >> mpFileHeader->nVersion >> mpFileHeader->nPad1 >>
 		mpFileHeader->nPad2 >> mpFileHeader->nChannels >> mpFileHeader->nRows >>
 			mpFileHeader->nColumns >> mpFileHeader->nDepth >> mpFileHeader->nMode;

 	if ( ( mpFileHeader->nSignature != 0x38425053 ) || ( mpFileHeader->nVersion != 1 ) )
 		return sal_False;

 	if ( mpFileHeader->nRows == 0 || mpFileHeader->nColumns == 0 )
 		return sal_False;

 	if ( ( mpFileHeader->nRows > 30000 ) || ( mpFileHeader->nColumns > 30000 ) )
 		return sal_False;

 	sal_uInt16 nDepth = mpFileHeader->nDepth;
 	if (!( ( nDepth == 1 ) || ( nDepth == 8 ) || ( nDepth == 16 ) ) )
 		return sal_False;

 	mnDestBitDepth = ( nDepth == 16 ) ? 8 : nDepth;

 	*mpPSD >> nColorLength;
 	if ( mpFileHeader->nMode == PSD_CMYK )
 	{
 		switch ( mpFileHeader->nChannels )
 		{
 			case 5 :
 				mbTransparent = sal_True;
 			case 4 :
 				mnDestBitDepth = 24;
 			break;
 			default :
 				return sal_False;
 		}
 	}
 	else switch ( mpFileHeader->nChannels )
 	{
 		case 2 :
 			mbTransparent = sal_True;
 		case 1 :
 			break;
 		case 4 :
 			mbTransparent = sal_True;
 		case 3 :
 			mnDestBitDepth = 24;
 			break;
 		default:
 			return sal_False;
 	}

 	switch ( mpFileHeader->nMode )
 	{
 		case PSD_BITMAP :
 		{
 			if ( nColorLength || ( nDepth != 1 ) )
 				return sal_False;
 		}
 		break;

 		case PSD_INDEXED :
 		{
 			if ( nColorLength != 768 )		// we need the color map
 				return sal_False;
 			mpPalette = new sal_uInt8[ 768 ];
 			if ( mpPalette == NULL )
 				return sal_False;
 			mpPSD->Read( mpPalette, 768 );
 		}
 		break;

 		case PSD_DUOTONE :					// we'll handle the doutone color like a normal grayscale picture
 			mpPSD->SeekRel( nColorLength );
 			nColorLength = 0;
 		case PSD_GRAYSCALE :
 		{
 			if ( nColorLength )
 				return sal_False;
 			mpPalette = new sal_uInt8[ 768 ];
 			if ( mpPalette == NULL )
 				return sal_False;
 			for ( sal_uInt16 i = 0; i < 256; i++ )
 			{
 				mpPalette[ i ] = mpPalette[ i + 256 ] = mpPalette[ i + 512 ] = (sal_uInt8)i;
 			}
 		}
 		break;

 		case PSD_CMYK :
 		case PSD_RGB :
 		case PSD_MULTICHANNEL :
 		case PSD_LAB :
 		{
 			if ( nColorLength )		// color table is not supported by the other graphic modes
 				return sal_False;
 		}
 		break;

 		default:
 			return sal_False;
 	}
     *mpPSD >> nResourceLength;
     sal_uInt32 nLayerPos = mpPSD->Tell() + nResourceLength;

     // this is a loop over the resource entries to get the resolution info
     while( mpPSD->Tell() < nLayerPos )
     {
         sal_uInt8 n8;
         sal_uInt32 nType, nPStringLen, nResEntryLen;
         sal_uInt16 nUniqueID;

         *mpPSD >> nType >> nUniqueID >> n8;
         nPStringLen = n8;
         if ( nType != 0x3842494d )
             break;
         if ( ! ( nPStringLen & 1 ) )
             nPStringLen++;
         mpPSD->SeekRel( nPStringLen );  // skipping the pstring
         *mpPSD >> nResEntryLen;
         if ( nResEntryLen & 1 )
             nResEntryLen++;             // the resource entries are padded
         sal_uInt32 nCurrentPos = mpPSD->Tell();
         if ( ( nResEntryLen + nCurrentPos ) > nLayerPos )   // check if size
             break;                                          // is possible
         switch( nUniqueID )
         {
             case 0x3ed :    // UID for the resolution info
             {
                 sal_Int16   nUnit;

                 *mpPSD >> mnXResFixed >> nUnit >> nUnit
                        >> mnYResFixed >> nUnit >> nUnit;
             }
             break;
         }
         mpPSD->Seek( nCurrentPos + nResEntryLen );          // set the stream to the next
     }                                                       // resource entry
     mpPSD->Seek( nLayerPos );
 	*mpPSD >> nLayerMaskLength;
 	mpPSD->SeekRel( nLayerMaskLength );

 	*mpPSD >> nCompression;
 	if ( nCompression == 0 )
 	{
 		mbCompression = sal_False;
 	}
 	else if ( nCompression == 1 )
 	{
 		mpPSD->SeekRel( ( mpFileHeader->nRows * mpFileHeader->nChannels ) << 1 );
 		mbCompression = sal_True;
 	}
 	else
 		return sal_False;

 	return sal_True;
 }

 // ------------------------------------------------------------------------

 sal_Bool PSDReader::ImplReadBody()
 {
 	sal_uLong		nX, nY;
 	char		nRunCount = 0;
 	signed char	nBitCount = -1;
 	sal_uInt8		nDat = 0, nDummy, nRed, nGreen, nBlue;
 	BitmapColor	aBitmapColor;
 	nX = nY = 0;

 	switch ( mnDestBitDepth )
 	{
 		case 1 :
 		{
 			while ( nY < mpFileHeader->nRows )
 			{
 				if ( nBitCount == -1 )
 				{
 					if ( mbCompression )	// else nRunCount = 0 -> so we use only single raw packets
 						*mpPSD >> nRunCount;
 				}
 				if ( nRunCount & 0x80 ) 	// a run length packet
 				{
 					if ( nBitCount == -1 )	// bits left in nDat ?
 					{
 						*mpPSD >> nDat;
 						nDat ^= 0xff;
 						nBitCount = 7;
 					}
 					for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 					{
 						mpWriteAcc->SetPixelIndex( nY, nX, nDat >> nBitCount-- );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							nBitCount = -1;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 				else						// a raw packet
 				{
 					for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 					{
 						if ( nBitCount == -1 )	// bits left in nDat ?
 						{
 							*mpPSD >> nDat;
 							nDat ^= 0xff;
 							nBitCount = 7;
 						}
 						mpWriteAcc->SetPixelIndex( nY, nX, nDat >> nBitCount-- );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							nBitCount = -1;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 			}
 		}
 		break;

 		case 8 :
 		{
 			while ( nY < mpFileHeader->nRows )
 			{
 				if ( mbCompression )		// else nRunCount = 0 -> so we use only single raw packets
 					*mpPSD >> nRunCount;

 				if ( nRunCount & 0x80 ) 	// a run length packet
 				{
 					*mpPSD >> nDat;
 					if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 						*mpPSD >> nDummy;
 					for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 					{
 						mpWriteAcc->SetPixelIndex( nY, nX, nDat );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 				else						// a raw packet
 				{
 					for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 					{
 						*mpPSD >> nDat;
 						if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 							*mpPSD >> nDummy;
 						mpWriteAcc->SetPixelIndex( nY, nX, nDat );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 			}
 		}
 		break;

 		case 24 :
 		{

 			// the psd format is in plain order (RRRR GGGG BBBB) so we have to set each pixel three times
 			// maybe the format is CCCC MMMM YYYY KKKK

 			while ( nY < mpFileHeader->nRows )
 			{
 				if ( mbCompression )		// else nRunCount = 0 -> so we use only single raw packets
 					*mpPSD >> nRunCount;

 				if ( nRunCount & 0x80 ) 	// a run length packet
 				{
 					*mpPSD >> nRed;
 					if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 						*mpPSD >> nDummy;
 					for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 					{
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (sal_uInt8)0, (sal_uInt8)0 ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 				else						// a raw packet
 				{
 					for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 					{
 						*mpPSD >> nRed;
 						if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 							*mpPSD >> nDummy;
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (sal_uInt8)0, (sal_uInt8)0 ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 			}
 			nY = 0;
 			while ( nY < mpFileHeader->nRows )
 			{
 				if ( mbCompression )
 					*mpPSD >> nRunCount;
 				if ( nRunCount & 0x80 ) 	// a run length packet
 				{
 					*mpPSD >> nGreen;
 					if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 						*mpPSD >> nDummy;
 					for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 					{
 						aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 				else						// a raw packet
 				{
 					for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 					{
 						*mpPSD >> nGreen;
 						if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 							*mpPSD >> nDummy;
 						aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 			}
 			nY = 0;
 			while ( nY < mpFileHeader->nRows )
 			{
 				if ( mbCompression )
 					*mpPSD >> nRunCount;
 				if ( nRunCount & 0x80 ) 	// a run length packet
 				{
 					*mpPSD >> nBlue;
 					if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 						*mpPSD >> nDummy;
 					for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 					{
 						aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 				else						// a raw packet
 				{
 					for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 					{
 						*mpPSD >> nBlue;
 						if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 							*mpPSD >> nDummy;
 						aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
 						if ( ++nX == mpFileHeader->nColumns )
 						{
 							nX = 0;
 							nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 						}
 					}
 				}
 			}
 			if ( mpFileHeader->nMode == PSD_CMYK )
 			{
 				sal_uInt32	nBlack, nBlackMax = 0;
 				sal_uInt8*	pBlack = new sal_uInt8[ mpFileHeader->nRows * mpFileHeader->nColumns ];
 				nY = 0;
 				while ( nY < mpFileHeader->nRows )
 				{
 					if ( mbCompression )		// else nRunCount = 0 -> so we use only single raw packets
 						*mpPSD >> nRunCount;

 					if ( nRunCount & 0x80 ) 	// a run length packet
 					{
 						*mpPSD >> nDat;

 						if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 							*mpPSD >> nDummy;

 						for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 						{
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
 							if ( ++nX == mpFileHeader->nColumns )
 							{
 								nX = 0;
 								nY++;
 							if ( nY == mpFileHeader->nRows )
 								break;
 							}
 						}
 					}
 					else						// a raw packet
 					{
 						for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 						{
 							*mpPSD >> nDat;

 							if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 								*mpPSD >> nDummy;
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
 							if ( nBlack > nBlackMax )
 								nBlackMax = nBlack;
 							pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
 							if ( ++nX == mpFileHeader->nColumns )
 							{
 								nX = 0;
 								nY++;
 								if ( nY == mpFileHeader->nRows )
 									break;
 							}
 						}
 					}
 				}

 				for ( nY = 0; nY < mpFileHeader->nRows; nY++ )
 				{
 					for ( nX = 0; nX < mpFileHeader->nColumns; nX++ )
 					{
 						sal_Int32 nDAT = pBlack[ nX + nY * mpFileHeader->nColumns ] * ( nBlackMax - 256 ) / 0x1ff;

 						aBitmapColor = mpReadAcc->GetPixel( nY, nX );
 						sal_uInt8 cR = (sal_uInt8) MinMax( aBitmapColor.GetRed() - nDAT, 0L, 255L );
 						sal_uInt8 cG = (sal_uInt8) MinMax( aBitmapColor.GetGreen() - nDAT, 0L, 255L );
 						sal_uInt8 cB = (sal_uInt8) MinMax( aBitmapColor.GetBlue() - nDAT, 0L, 255L );
 						mpWriteAcc->SetPixel( nY, nX, BitmapColor( cR, cG, cB ) );
 					}
 				}
 				delete[] pBlack;
 			}
 		}
 		break;
 	}

 	if ( mbTransparent )
 	{
 		// the psd is 24 or 8 bit grafix + alphachannel

 		nY = nX = 0;
 		while ( nY < mpFileHeader->nRows )
 		{
 			if ( mbCompression )		// else nRunCount = 0 -> so we use only single raw packets
 				*mpPSD >> nRunCount;

 			if ( nRunCount & 0x80 ) 	// a run length packet
 			{
 				*mpPSD >> nDat;
 				if ( nDat )
 					nDat = 0;
 				else
 					nDat = 1;
 				if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 					*mpPSD >> nDummy;
 				for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
 				{
 					mpMaskWriteAcc->SetPixelIndex( nY, nX, nDat );
 					if ( ++nX == mpFileHeader->nColumns )
 					{
 						nX = 0;
 						nY++;
 						if ( nY == mpFileHeader->nRows )
 							break;
 					}
 				}
 			}
 			else						// a raw packet
 			{
 				for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
 				{
 					*mpPSD >> nDat;
 					if ( nDat )
 						nDat = 0;
 					else
 						nDat = 1;
 					if ( mpFileHeader->nDepth == 16 )	// 16 bit depth is to be skipped
 						*mpPSD >> nDummy;
 					mpMaskWriteAcc->SetPixelIndex( nY, nX, nDat );
 					if ( ++nX == mpFileHeader->nColumns )
 					{
 						nX = 0;
 						nY++;
 						if ( nY == mpFileHeader->nRows )
 							break;
 					}
 				}
 			}
 		}
 	}
 	return sal_True;
 }

 //================== GraphicImport - die exportierte Funktion ================

 extern "C" sal_Bool __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool )
 {
 	PSDReader aPSDReader;

 	return aPSDReader.ReadPSD( rStream, rGraphic );
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_filter.hxx"

	#include <vcl/graph.hxx>
	#include <vcl/bmpacc.hxx>
	#include <svtools/fltcall.hxx>

	//============================ PSDReader ==================================

	#define PSD_BITMAP 0
	#define PSD_GRAYSCALE 1
	#define PSD_INDEXED 2
	#define PSD_RGB 3
	#define PSD_CMYK 4
	#define PSD_MULTICHANNEL 7
	#define PSD_DUOTONE 8
	#define PSD_LAB 9

	typedef struct
	{
	sal_uInt32 nSignature;
	sal_uInt16 nVersion;
	sal_uInt32 nPad1;
	sal_uInt16 nPad2;
	sal_uInt16 nChannels;
	sal_uInt32 nRows;
	sal_uInt32 nColumns;
	sal_uInt16 nDepth;
	sal_uInt16 nMode;

	} PSDFileHeader;

	class PSDReader {

	private:

	SvStream* mpPSD; // Die einzulesende PSD-Datei
	PSDFileHeader* mpFileHeader;

	sal_uInt32 mnXResFixed;
	sal_uInt32 mnYResFixed;

	sal_Bool mbStatus;
	sal_Bool mbTransparent;

	Bitmap maBmp;
	Bitmap maMaskBmp;
	BitmapReadAccess* mpReadAcc;
	BitmapWriteAccess* mpWriteAcc;
	BitmapWriteAccess* mpMaskWriteAcc;
	sal_uInt16 mnDestBitDepth;
	sal_Bool mbCompression; // RLE decoding
	sal_uInt8* mpPalette;

	sal_Bool ImplReadBody();
	sal_Bool ImplReadHeader();

	public:
	PSDReader();
	~PSDReader();
	sal_Bool ReadPSD( SvStream & rPSD, Graphic & rGraphic );
	};

	//=================== Methoden von PSDReader ==============================

	PSDReader::PSDReader() :
	mpFileHeader ( NULL ),
	mnXResFixed ( 0 ),
	mnYResFixed ( 0 ),
	mbStatus ( sal_True ),
	mbTransparent ( sal_False ),
	mpReadAcc ( NULL ),
	mpWriteAcc ( NULL ),
	mpMaskWriteAcc ( NULL ),
	mpPalette ( NULL )
	{
	}

	PSDReader::~PSDReader()
	{
	delete[] mpPalette;
	delete mpFileHeader;
	}

	// ------------------------------------------------------------------------

	sal_Bool PSDReader::ReadPSD( SvStream & rPSD, Graphic & rGraphic )
	{
	if ( rPSD.GetError() )
	return sal_False;

	mpPSD = &rPSD;
	mpPSD->SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );

	// Kopf einlesen:

	if ( ImplReadHeader() == sal_False )
	return sal_False;

	Size aBitmapSize( mpFileHeader->nColumns, mpFileHeader->nRows );
	maBmp = Bitmap( aBitmapSize, mnDestBitDepth );
	if ( ( mpWriteAcc = maBmp.AcquireWriteAccess() ) == NULL )
	mbStatus = sal_False;
	if ( ( mpReadAcc = maBmp.AcquireReadAccess() ) == NULL )
	mbStatus = sal_False;
	if ( mbTransparent && mbStatus )
	{
	maMaskBmp = Bitmap( aBitmapSize, 1 );
	if ( ( mpMaskWriteAcc = maMaskBmp.AcquireWriteAccess() ) == NULL )
	mbStatus = sal_False;
	}
	if ( mpPalette && mbStatus )
	{
	mpWriteAcc->SetPaletteEntryCount( 256 );
	for ( sal_uInt16 i = 0; i < 256; i++ )
	{
	mpWriteAcc->SetPaletteColor( i, Color( mpPalette[ i ], mpPalette[ i + 256 ], mpPalette[ i + 512 ] ) );
	}
	}
	// Bitmap-Daten einlesen
	if ( mbStatus && ImplReadBody() )
	{
	if ( mbTransparent )
	rGraphic = Graphic( BitmapEx( maBmp, maMaskBmp ) );
	else
	rGraphic = maBmp;

	if ( mnXResFixed && mnYResFixed )
	{
	Point aEmptyPoint;
	Fraction aFractX( 1, mnXResFixed >> 16 );
	Fraction aFractY( 1, mnYResFixed >> 16 );
	MapMode aMapMode( MAP_INCH, aEmptyPoint, aFractX, aFractY );
	Size aPrefSize = OutputDevice::LogicToLogic( aBitmapSize, aMapMode, MAP_100TH_MM );
	rGraphic.SetPrefSize( aPrefSize );
	rGraphic.SetPrefMapMode( MapMode( MAP_100TH_MM ) );
	}
	}
	else
	mbStatus = sal_False;
	if ( mpWriteAcc )
	maBmp.ReleaseAccess( mpWriteAcc );
	if ( mpReadAcc )
	maBmp.ReleaseAccess( mpReadAcc );
	if ( mpMaskWriteAcc )
	maMaskBmp.ReleaseAccess( mpMaskWriteAcc );
	return mbStatus;
	}

	// ------------------------------------------------------------------------

	sal_Bool PSDReader::ImplReadHeader()
	{
	sal_uInt16 nCompression;
	sal_uInt32 nColorLength, nResourceLength, nLayerMaskLength;

	mpFileHeader = new PSDFileHeader;

	if ( !mpFileHeader )
	return sal_False;

	*mpPSD >> mpFileHeader->nSignature >> mpFileHeader->nVersion >> mpFileHeader->nPad1 >>
	mpFileHeader->nPad2 >> mpFileHeader->nChannels >> mpFileHeader->nRows >>
	mpFileHeader->nColumns >> mpFileHeader->nDepth >> mpFileHeader->nMode;

	if ( ( mpFileHeader->nSignature != 0x38425053 ) \|\| ( mpFileHeader->nVersion != 1 ) )
	return sal_False;

	if ( mpFileHeader->nRows == 0 \|\| mpFileHeader->nColumns == 0 )
	return sal_False;

	if ( ( mpFileHeader->nRows > 30000 ) \|\| ( mpFileHeader->nColumns > 30000 ) )
	return sal_False;

	sal_uInt16 nDepth = mpFileHeader->nDepth;
	if (!( ( nDepth == 1 ) \|\| ( nDepth == 8 ) \|\| ( nDepth == 16 ) ) )
	return sal_False;

	mnDestBitDepth = ( nDepth == 16 ) ? 8 : nDepth;

	*mpPSD >> nColorLength;
	if ( mpFileHeader->nMode == PSD_CMYK )
	{
	switch ( mpFileHeader->nChannels )
	{
	case 5 :
	mbTransparent = sal_True;
	case 4 :
	mnDestBitDepth = 24;
	break;
	default :
	return sal_False;
	}
	}
	else switch ( mpFileHeader->nChannels )
	{
	case 2 :
	mbTransparent = sal_True;
	case 1 :
	break;
	case 4 :
	mbTransparent = sal_True;
	case 3 :
	mnDestBitDepth = 24;
	break;
	default:
	return sal_False;
	}

	switch ( mpFileHeader->nMode )
	{
	case PSD_BITMAP :
	{
	if ( nColorLength \|\| ( nDepth != 1 ) )
	return sal_False;
	}
	break;

	case PSD_INDEXED :
	{
	if ( nColorLength != 768 ) // we need the color map
	return sal_False;
	mpPalette = new sal_uInt8[ 768 ];
	if ( mpPalette == NULL )
	return sal_False;
	mpPSD->Read( mpPalette, 768 );
	}
	break;

	case PSD_DUOTONE : // we'll handle the doutone color like a normal grayscale picture
	mpPSD->SeekRel( nColorLength );
	nColorLength = 0;
	case PSD_GRAYSCALE :
	{
	if ( nColorLength )
	return sal_False;
	mpPalette = new sal_uInt8[ 768 ];
	if ( mpPalette == NULL )
	return sal_False;
	for ( sal_uInt16 i = 0; i < 256; i++ )
	{
	mpPalette[ i ] = mpPalette[ i + 256 ] = mpPalette[ i + 512 ] = (sal_uInt8)i;
	}
	}
	break;

	case PSD_CMYK :
	case PSD_RGB :
	case PSD_MULTICHANNEL :
	case PSD_LAB :
	{
	if ( nColorLength ) // color table is not supported by the other graphic modes
	return sal_False;
	}
	break;

	default:
	return sal_False;
	}
	*mpPSD >> nResourceLength;
	sal_uInt32 nLayerPos = mpPSD->Tell() + nResourceLength;

	// this is a loop over the resource entries to get the resolution info
	while( mpPSD->Tell() < nLayerPos )
	{
	sal_uInt8 n8;
	sal_uInt32 nType, nPStringLen, nResEntryLen;
	sal_uInt16 nUniqueID;

	*mpPSD >> nType >> nUniqueID >> n8;
	nPStringLen = n8;
	if ( nType != 0x3842494d )
	break;
	if ( ! ( nPStringLen & 1 ) )
	nPStringLen++;
	mpPSD->SeekRel( nPStringLen ); // skipping the pstring
	*mpPSD >> nResEntryLen;
	if ( nResEntryLen & 1 )
	nResEntryLen++; // the resource entries are padded
	sal_uInt32 nCurrentPos = mpPSD->Tell();
	if ( ( nResEntryLen + nCurrentPos ) > nLayerPos ) // check if size
	break; // is possible
	switch( nUniqueID )
	{
	case 0x3ed : // UID for the resolution info
	{
	sal_Int16 nUnit;

	*mpPSD >> mnXResFixed >> nUnit >> nUnit
	>> mnYResFixed >> nUnit >> nUnit;
	}
	break;
	}
	mpPSD->Seek( nCurrentPos + nResEntryLen ); // set the stream to the next
	} // resource entry
	mpPSD->Seek( nLayerPos );
	*mpPSD >> nLayerMaskLength;
	mpPSD->SeekRel( nLayerMaskLength );

	*mpPSD >> nCompression;
	if ( nCompression == 0 )
	{
	mbCompression = sal_False;
	}
	else if ( nCompression == 1 )
	{
	mpPSD->SeekRel( ( mpFileHeader->nRows * mpFileHeader->nChannels ) << 1 );
	mbCompression = sal_True;
	}
	else
	return sal_False;

	return sal_True;
	}

	// ------------------------------------------------------------------------

	sal_Bool PSDReader::ImplReadBody()
	{
	sal_uLong nX, nY;
	char nRunCount = 0;
	signed char nBitCount = -1;
	sal_uInt8 nDat = 0, nDummy, nRed, nGreen, nBlue;
	BitmapColor aBitmapColor;
	nX = nY = 0;

	switch ( mnDestBitDepth )
	{
	case 1 :
	{
	while ( nY < mpFileHeader->nRows )
	{
	if ( nBitCount == -1 )
	{
	if ( mbCompression ) // else nRunCount = 0 -> so we use only single raw packets
	*mpPSD >> nRunCount;
	}
	if ( nRunCount & 0x80 ) // a run length packet
	{
	if ( nBitCount == -1 ) // bits left in nDat ?
	{
	*mpPSD >> nDat;
	nDat ^= 0xff;
	nBitCount = 7;
	}
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	mpWriteAcc->SetPixelIndex( nY, nX, nDat >> nBitCount-- );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	nBitCount = -1;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	if ( nBitCount == -1 ) // bits left in nDat ?
	{
	*mpPSD >> nDat;
	nDat ^= 0xff;
	nBitCount = 7;
	}
	mpWriteAcc->SetPixelIndex( nY, nX, nDat >> nBitCount-- );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	nBitCount = -1;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	}
	break;

	case 8 :
	{
	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression ) // else nRunCount = 0 -> so we use only single raw packets
	*mpPSD >> nRunCount;

	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nDat;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	mpWriteAcc->SetPixelIndex( nY, nX, nDat );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nDat;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	mpWriteAcc->SetPixelIndex( nY, nX, nDat );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	}
	break;

	case 24 :
	{

	// the psd format is in plain order (RRRR GGGG BBBB) so we have to set each pixel three times
	// maybe the format is CCCC MMMM YYYY KKKK

	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression ) // else nRunCount = 0 -> so we use only single raw packets
	*mpPSD >> nRunCount;

	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nRed;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (sal_uInt8)0, (sal_uInt8)0 ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nRed;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( nRed, (sal_uInt8)0, (sal_uInt8)0 ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	nY = 0;
	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression )
	*mpPSD >> nRunCount;
	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nGreen;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	aBitmapColor = mpReadAcc->GetPixel( nY, nX );
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nGreen;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	aBitmapColor = mpReadAcc->GetPixel( nY, nX );
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), nGreen, aBitmapColor.GetBlue() ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	nY = 0;
	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression )
	*mpPSD >> nRunCount;
	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nBlue;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	aBitmapColor = mpReadAcc->GetPixel( nY, nX );
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nBlue;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	aBitmapColor = mpReadAcc->GetPixel( nY, nX );
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( aBitmapColor.GetRed(), aBitmapColor.GetGreen(), nBlue ) );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	if ( mpFileHeader->nMode == PSD_CMYK )
	{
	sal_uInt32 nBlack, nBlackMax = 0;
	sal_uInt8* pBlack = new sal_uInt8[ mpFileHeader->nRows * mpFileHeader->nColumns ];
	nY = 0;
	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression ) // else nRunCount = 0 -> so we use only single raw packets
	*mpPSD >> nRunCount;

	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nDat;

	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;

	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nDat;

	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetRed() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetGreen() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	nBlack = (sal_uInt8)mpReadAcc->GetPixel( nY, nX ).GetBlue() + nDat;
	if ( nBlack > nBlackMax )
	nBlackMax = nBlack;
	pBlack[ nX + nY * mpFileHeader->nColumns ] = nDat ^ 0xff;
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}

	for ( nY = 0; nY < mpFileHeader->nRows; nY++ )
	{
	for ( nX = 0; nX < mpFileHeader->nColumns; nX++ )
	{
	sal_Int32 nDAT = pBlack[ nX + nY * mpFileHeader->nColumns ] * ( nBlackMax - 256 ) / 0x1ff;

	aBitmapColor = mpReadAcc->GetPixel( nY, nX );
	sal_uInt8 cR = (sal_uInt8) MinMax( aBitmapColor.GetRed() - nDAT, 0L, 255L );
	sal_uInt8 cG = (sal_uInt8) MinMax( aBitmapColor.GetGreen() - nDAT, 0L, 255L );
	sal_uInt8 cB = (sal_uInt8) MinMax( aBitmapColor.GetBlue() - nDAT, 0L, 255L );
	mpWriteAcc->SetPixel( nY, nX, BitmapColor( cR, cG, cB ) );
	}
	}
	delete[] pBlack;
	}
	}
	break;
	}

	if ( mbTransparent )
	{
	// the psd is 24 or 8 bit grafix + alphachannel

	nY = nX = 0;
	while ( nY < mpFileHeader->nRows )
	{
	if ( mbCompression ) // else nRunCount = 0 -> so we use only single raw packets
	*mpPSD >> nRunCount;

	if ( nRunCount & 0x80 ) // a run length packet
	{
	*mpPSD >> nDat;
	if ( nDat )
	nDat = 0;
	else
	nDat = 1;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	for ( sal_uInt16 i = 0; i < ( -nRunCount + 1 ); i++ )
	{
	mpMaskWriteAcc->SetPixelIndex( nY, nX, nDat );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	else // a raw packet
	{
	for ( sal_uInt16 i = 0; i < ( ( nRunCount & 0x7f ) + 1 ); i++ )
	{
	*mpPSD >> nDat;
	if ( nDat )
	nDat = 0;
	else
	nDat = 1;
	if ( mpFileHeader->nDepth == 16 ) // 16 bit depth is to be skipped
	*mpPSD >> nDummy;
	mpMaskWriteAcc->SetPixelIndex( nY, nX, nDat );
	if ( ++nX == mpFileHeader->nColumns )
	{
	nX = 0;
	nY++;
	if ( nY == mpFileHeader->nRows )
	break;
	}
	}
	}
	}
	}
	return sal_True;
	}

	//================== GraphicImport - die exportierte Funktion ================

	extern "C" sal_Bool __LOADONCALLAPI GraphicImport(SvStream & rStream, Graphic & rGraphic, FilterConfigItem*, sal_Bool )
	{
	PSDReader aPSDReader;

	return aPSDReader.ReadPSD( rStream, rGraphic );
	}