/**************************************************************
 * 
 * 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>

//============================ PBMReader ==================================

class PBMReader {

private:

	SvStream*			mpPBM;			// Die einzulesende PBM-Datei

	sal_Bool				mbStatus;
	sal_Bool				mbRemark;		// sal_False wenn sich stream in einem Kommentar befindet
	sal_Bool				mbRaw;			// RAW/ASCII MODE
	sal_uLong				mnMode;			// 0->PBM, 1->PGM, 2->PPM
	Bitmap				maBmp;
	BitmapWriteAccess*	mpAcc;
	sal_uLong				mnWidth, mnHeight;	// Bildausmass in Pixeln
	sal_uLong				mnCol;
	sal_uLong				mnMaxVal;			// maximaler wert in den
	sal_Bool				ImplCallback( sal_uInt16 nPercent );
	sal_Bool				ImplReadBody();
	sal_Bool				ImplReadHeader();

public:
						PBMReader();
						~PBMReader();
	sal_Bool				ReadPBM( SvStream & rPBM, Graphic & rGraphic );
};

//=================== Methoden von PBMReader ==============================

PBMReader::PBMReader() :
	mbStatus	( sal_True ),
	mbRemark	( sal_False ),
	mbRaw		( sal_True ),
	mpAcc		( NULL )
{
}

PBMReader::~PBMReader()
{
}

sal_Bool PBMReader::ImplCallback( sal_uInt16 /*nPercent*/ )
{
/*
	if ( pCallback != NULL )
	{
		if ( ( (*pCallback)( pCallerData, nPercent ) ) == sal_True )
		{
			mpPBM->SetError( SVSTREAM_FILEFORMAT_ERROR );
			return sal_True;
		}
	}
*/
	return sal_False;
}

sal_Bool PBMReader::ReadPBM( SvStream & rPBM, Graphic & rGraphic )
{
	sal_uInt16 i;

	if ( rPBM.GetError() )
		return sal_False;

	mpPBM = &rPBM;
	mpPBM->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );

	// Kopf einlesen:

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

	if ( ( mnMaxVal == 0 ) || ( mnWidth == 0 ) || ( mnHeight == 0 ) )
		return sal_False;

	// 0->PBM, 1->PGM, 2->PPM
	switch ( mnMode )
	{
		case 0 :
			maBmp = Bitmap( Size( mnWidth, mnHeight ), 1 );
			mpAcc = maBmp.AcquireWriteAccess();
			if ( !mpAcc )
				return sal_False;
			mpAcc->SetPaletteEntryCount( 2 );
			mpAcc->SetPaletteColor( 0, BitmapColor( 0xff, 0xff, 0xff ) );
			mpAcc->SetPaletteColor( 1, BitmapColor( 0x00, 0x00, 0x00 ) );
			break;

		case 1 :
			if ( mnMaxVal <= 1 )
				maBmp = Bitmap( Size( mnWidth, mnHeight ), 1);
			else if ( mnMaxVal <= 15 )
				maBmp = Bitmap( Size( mnWidth, mnHeight ), 4);
			else
				maBmp = Bitmap( Size( mnWidth, mnHeight ), 8);

			mpAcc = maBmp.AcquireWriteAccess();
			if ( !mpAcc )
				return sal_False;
			mnCol = (sal_uInt16)mnMaxVal + 1;
			if ( mnCol > 256 )
				mnCol = 256;

			mpAcc->SetPaletteEntryCount( 256 );
			for ( i = 0; i < mnCol; i++ )
			{
				sal_uLong nCount = 255 * i / mnCol;
				mpAcc->SetPaletteColor( i, BitmapColor( (sal_uInt8)nCount, (sal_uInt8)nCount, (sal_uInt8)nCount ) );
			}
			break;
		case 2 :
			maBmp = Bitmap( Size( mnWidth, mnHeight ), 24 );
			mpAcc = maBmp.AcquireWriteAccess();
			if ( !mpAcc )
				return sal_False;
			break;
	}

	// Bitmap-Daten einlesen
	mbStatus = ImplReadBody();

	if ( mpAcc )
	{
		maBmp.ReleaseAccess( mpAcc ), mpAcc = NULL;
	}
	if ( mbStatus )
		rGraphic = maBmp;

	return mbStatus;
}

sal_Bool PBMReader::ImplReadHeader()
{
	sal_uInt8	nID[ 2 ];
	sal_uInt8	nDat;
	sal_uInt8	nMax, nCount = 0;
	sal_Bool	bFinished = sal_False;

	*mpPBM >> nID[ 0 ] >> nID[ 1 ];
	if ( nID[ 0 ] != 'P' )
		return sal_False;
	mnMaxVal = mnWidth = mnHeight = 0;
	switch ( nID[ 1 ] )
	{
		case '1' :
			mbRaw = sal_False;
		case '4' :
			mnMode = 0;
			nMax = 2;				// number of parameters in Header
			mnMaxVal = 1;
			break;
		case '2' :
			mbRaw = sal_False;
		case '5' :
			mnMode = 1;
			nMax = 3;
			break;
		case '3' :
			mbRaw = sal_False;
		case '6' :
			mnMode = 2;
			nMax = 3;
			break;
		default:
			return sal_False;
	}
	while ( bFinished == sal_False )
	{
		if ( mpPBM->GetError() )
			return sal_False;

		*mpPBM >> nDat;

		if ( nDat == '#' )
		{
			mbRemark = sal_True;
			continue;
		}
		else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
		{
			mbRemark = sal_False;
			nDat = 0x20;
		}
		if ( mbRemark )
			continue;

		if ( ( nDat == 0x20 ) || ( nDat == 0x09 ) )
		{
			if ( ( nCount == 0 ) && mnWidth )
				nCount++;
			else if ( ( nCount == 1 ) && mnHeight )
			{
				if ( ++nCount == nMax )
					bFinished = sal_True;
			}
			else if ( ( nCount == 2 ) && mnMaxVal )
			{
				bFinished = sal_True;
			}
			continue;
		}
		if ( ( nDat >= '0' ) && ( nDat <= '9' ) )
		{
			nDat -= '0';
			if ( nCount == 0 )
			{
				mnWidth *= 10;
				mnWidth += nDat;
			}
			else if ( nCount == 1 )
			{
				mnHeight *= 10;
				mnHeight += nDat;
			}
			else if ( nCount == 2 )
			{
				mnMaxVal *= 10;
				mnMaxVal += nDat;
			}
		}
		else
			return sal_False;
	}
	return mbStatus;
}

sal_Bool PBMReader::ImplReadBody()
{
	sal_Bool	bPara, bFinished = sal_False;
	sal_uInt8	nDat = 0, nCount;
	sal_uLong	nGrey, nRGB[3];
	sal_uLong	nWidth = 0;
	sal_uLong	nHeight = 0;
	signed char	nShift = 0;

	if ( mbRaw )
	{
		switch ( mnMode )
		{

			// PBM
			case 0 :
				while ( nHeight != mnHeight )
				{
					if ( mpPBM->IsEof() || mpPBM->GetError() )
						return sal_False;

					if ( --nShift < 0 )
					{
						*mpPBM >> nDat;
						nShift = 7;
					}
					mpAcc->SetPixelIndex( nHeight, nWidth, nDat >> nShift );
					if ( ++nWidth == mnWidth )
					{
						nShift = 0;
						nWidth = 0;
						nHeight++;
						ImplCallback( (sal_uInt16)( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
				}
				break;

			// PGM
			case 1 :
				while ( nHeight != mnHeight )
				{
					if ( mpPBM->IsEof() || mpPBM->GetError() )
						return sal_False;

					*mpPBM >> nDat;
					mpAcc->SetPixelIndex( nHeight, nWidth++, nDat);

					if ( nWidth == mnWidth )
					{
						nWidth = 0;
						nHeight++;
						ImplCallback( (sal_uInt16)( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
				}
				break;

			// PPM
			case 2 :
				while ( nHeight != mnHeight )
				{
					if ( mpPBM->IsEof() || mpPBM->GetError() )
						return sal_False;

					sal_uInt8	nR, nG, nB;
					sal_uLong	nRed, nGreen, nBlue;
					*mpPBM >> nR >> nG >> nB;
					nRed = 255 * nR / mnMaxVal;
					nGreen = 255 * nG / mnMaxVal;
					nBlue = 255 * nB / mnMaxVal;
					mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( (sal_uInt8)nRed, (sal_uInt8)nGreen, (sal_uInt8)nBlue ) );
					if ( nWidth == mnWidth )
					{
						nWidth = 0;
						nHeight++;
						ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
				}
				break;
		}
	}
	else switch  ( mnMode )
	{
		// PBM
		case 0 :
			while ( bFinished == sal_False )
			{
				if ( mpPBM->IsEof() || mpPBM->GetError() )
					return sal_False;

				*mpPBM >> nDat;

				if ( nDat == '#' )
				{
					mbRemark = sal_True;
					continue;
				}
				else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
				{
					mbRemark = sal_False;
					continue;
				}
				if ( mbRemark || nDat == 0x20 || nDat == 0x09 )
					continue;

				if ( nDat == '0' || nDat == '1' )
				{
					mpAcc->SetPixelIndex( nHeight, nWidth, static_cast<sal_uInt8>(nDat - '0') );
					nWidth++;
					if ( nWidth == mnWidth )
					{
						nWidth = 0;
						if ( ++nHeight == mnHeight )
							bFinished = sal_True;
						ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
				}
				else
					return sal_False;
			}
			break;

		// PGM
		case 1 :

			bPara = sal_False;
			nCount = 0;
			nGrey = 0;

			while ( bFinished == sal_False )
			{
				if ( nCount )
				{
					nCount--;
					if ( nGrey <= mnMaxVal )
						nGrey = 255 * nGrey / mnMaxVal;
						mpAcc->SetPixelIndex( nHeight, nWidth++, static_cast<sal_uInt8>(nGrey) );
					nGrey = 0;
					if ( nWidth == mnWidth )
					{
						nWidth = 0;
						if ( ++nHeight == mnHeight )
							bFinished = sal_True;
						ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
					continue;
				}

				if ( mpPBM->IsEof() || mpPBM->GetError() )
					return sal_False;

				*mpPBM >> nDat;

				if ( nDat == '#' )
				{
					mbRemark = sal_True;
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}
				else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
				{
					mbRemark = sal_False;
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}

				if ( nDat == 0x20 || nDat == 0x09 )
				{
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}
				if ( nDat >= '0' && nDat <= '9' )
				{
					bPara = sal_True;
					nGrey *= 10;
					nGrey += nDat-'0';
					continue;
				}
				else
					return sal_False;
			}
			break;



		// PPM
		case 2 :

			bPara = sal_False;
			nCount = 0;
			nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;

			while ( bFinished == sal_False )
			{
				if ( nCount == 3 )
				{
					nCount = 0;
					mpAcc->SetPixel( nHeight, nWidth++, BitmapColor( static_cast< sal_uInt8 >( ( nRGB[ 0 ] * 255 ) / mnMaxVal ),
																	 static_cast< sal_uInt8 >( ( nRGB[ 1 ] * 255 ) / mnMaxVal ),
																	 static_cast< sal_uInt8 >( ( nRGB[ 2 ] * 255 ) / mnMaxVal ) ) );
					nCount = 0;
					nRGB[ 0 ] = nRGB[ 1 ] = nRGB[ 2 ] = 0;
					if ( nWidth == mnWidth )
					{
						nWidth = 0;
						if ( ++nHeight == mnHeight )
							bFinished = sal_True;
						ImplCallback( (sal_uInt16) ( ( 100 * nHeight ) / mnHeight ) );	// processing output in percent
					}
					continue;
				}

				if ( mpPBM->IsEof() || mpPBM->GetError() )
					return sal_False;

				*mpPBM >> nDat;

				if ( nDat == '#' )
				{
					mbRemark = sal_True;
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}
				else if ( ( nDat == 0x0d ) || ( nDat == 0x0a ) )
				{
					mbRemark = sal_False;
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}

				if ( nDat == 0x20 || nDat == 0x09 )
				{
					if ( bPara )
					{
						bPara = sal_False;
						nCount++;
					}
					continue;
				}
				if ( nDat >= '0' && nDat <= '9' )
				{
					bPara = sal_True;
					nRGB[ nCount ] *= 10;
					nRGB[ nCount ] += nDat-'0';
					continue;
				}
				else
					return sal_False;
			}
			break;
	}
	return mbStatus;
}

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

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

	return aPBMReader.ReadPBM( rStream, rGraphic );
}