// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <icl/imageprocessor.h>

#include "ImageProcessorPriv.h"

#include "ImageUtils.h"

#include "ImageClientMain.h"

//Size of dynamically allocated buffers used by CPixelWriter & CMonochromePixelWriter

const TInt KPixelWriterBufferSize = 1024;

const TInt KPixelWriterBufferThreeQuarter = 768;

/**

Constructor for this class.

*/

EXPORT_C CImageProcessorExtension::CImageProcessorExtension()

:iOperation(EDecodeNormal)

	{

	}

/**

Destructor for this class.

*/

EXPORT_C CImageProcessorExtension::~CImageProcessorExtension()

	{

	}

/**

Sets the area of interest of the image to be decoded.

@param aRect

	   A reference to a TRect that specifies the location and size of the region to be decoded.

*/

EXPORT_C void CImageProcessorExtension::SetClippingRect(const TRect& aRect)

	{

	iClippingRect = aRect;

	}

/**

Sets the scaling coefficient for the decode.

@param aScalingCoeff

	   The scaling coefficient.

@see TImageConvScaler::SetScalingL

*/

EXPORT_C void CImageProcessorExtension::SetScaling(TInt aScalingCoeff)

	{

	iScalingCoeff = aScalingCoeff;

	}

/**

Sets the desired size of the destination image for the decode.

@param aDesiredSize

	   The desired size of the destination image.

@see TImageConvScaler::SetScalingL

*/

EXPORT_C void CImageProcessorExtension::SetScaling(const TSize& aDesiredSize)

	{

	iDesiredSize = aDesiredSize;

	}

/**

Sets the operation to be applied to the image.

@param aOperation

	   The operation to apply to the image.

@see TImageConvScaler::SetScalingL

*/

EXPORT_C void CImageProcessorExtension::SetOperation(TTransformOptions aOperation)

	{

	iOperation = aOperation;

	}

/**

Sets an initial one-off number of scanlines to be skipped.

This must be called prior to calling SetYPosIncrement(),

if it is to be used.

@param  aNumberOfScanlines

        The number of scanlines to skip.

@see CImageProcessor::SetYPosIncrement()

*/

EXPORT_C void CImageProcessorExtension::SetInitialScanlineSkipPadding(TInt aNumberOfScanlines)

	{

	iNumberOfScanlinesToSkip = aNumberOfScanlines;

	}

//

// ImageProcessorUtility

//

//

//	CColorImageProcessor

//

/**

 * @see CImageProcessor.

 * @internalComponent

 */

void CColorImageProcessor::CreateBlockBufferL(TInt aBlockArea)

	{

	delete[] iBlockBuffer;

	iBlockBuffer = NULL;

	if(aBlockArea)

		iBlockBuffer = new (ELeave) TRgb[aBlockArea];

	iBlockArea = aBlockArea;

	}

/**

 * Destructor.

 * @see CImageProcessor.

 * @internalComponent

 */

CColorImageProcessor::~CColorImageProcessor()

	{

	delete[] iBlockBuffer;

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetPixelRun(TRgb aColor,TInt aCount)

	{

	TBool returnValue = EFalse;

	while(aCount--)

		returnValue |= SetPixel(aColor);

	return returnValue;

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetPixels(TRgb* aColorBuffer,TInt aBufferLength)

	{

	TBool returnValue = EFalse;

	while(aBufferLength--)

		returnValue |= SetPixel(*aColorBuffer++);

	return returnValue;

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetMonoPixel(TInt aGray256)

	{

	return SetPixel(TRgb(aGray256,aGray256,aGray256));

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetMonoPixelRun(TInt aGray256,TInt aCount)

	{

	return SetPixelRun(TRgb(aGray256,aGray256,aGray256),aCount);

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetMonoPixels(TUint32* aGray256Buffer,TInt aBufferLength)

	{

	TBool returnValue = EFalse;

	while(aBufferLength--)

		{

		TUint32 gray256 = *aGray256Buffer++;

		returnValue = SetPixel(TRgb(gray256,gray256,gray256));

		}

	return returnValue;

	}

/**

 * @see CImageProcessor.

 * @internalComponent

 */

TBool CColorImageProcessor::SetMonoPixelBlock(TUint32* aGray256Buffer)

	{

	ASSERT(iBlockBuffer);

	TRgb* blockBufferPtr = iBlockBuffer;

	TRgb* blockBufferPtrLimit = blockBufferPtr+iBlockArea;

	while(blockBufferPtr<blockBufferPtrLimit)

		{

		TUint32 gray256 = *aGray256Buffer++;

		*blockBufferPtr++ = TRgb(gray256,gray256,gray256);

		}

	return SetPixelBlock(iBlockBuffer);

	}

//

//	CMonochromeImageProcessor

//

/**

 * @see CImageProcessor.

 */

void CMonochromeImageProcessor::CreateBlockBufferL(TInt aBlockArea)

	{

	delete[] iBlockBuffer;

	iBlockBuffer = NULL;

	iBlockBuffer = new (ELeave) TUint32[aBlockArea];

	iBlockArea = aBlockArea;

	}

/**

 * Destructor.

 * @see CImageProcessor.

 */

CMonochromeImageProcessor::~CMonochromeImageProcessor()

	{

	delete []iBlockBuffer;

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetMonoPixelRun(TInt aGray256,TInt aCount)

	{

	TBool returnValue = EFalse;

	while(aCount--)

		returnValue = SetMonoPixel(aGray256);

	return returnValue;

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetMonoPixels(TUint32* aGray256Buffer,TInt aBufferLength)

	{

	TBool returnValue = EFalse;

	while(aBufferLength--)

		returnValue = SetMonoPixel(*aGray256Buffer++);

	return returnValue;

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetPixel(TRgb aColor)

	{

	return SetMonoPixel(TColorConvertor::RgbToMonochrome(aColor));

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetPixelRun(TRgb aColor,TInt aCount)

	{

	return SetMonoPixelRun(TColorConvertor::RgbToMonochrome(aColor),aCount);

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetPixels(TRgb* aColorBuffer,TInt aBufferLength)

	{

	TBool returnValue = EFalse;

	while(aBufferLength--)

		returnValue = SetMonoPixel(TColorConvertor::RgbToMonochrome(*aColorBuffer++));

	return returnValue;

	}

/**

 * @see CImageProcessor.

 */

TBool CMonochromeImageProcessor::SetPixelBlock(TRgb* aColorBuffer)

	{

	ASSERT(iBlockBuffer);

	TUint32* blockBufferPtr = iBlockBuffer;

	TUint32* blockBufferPtrLimit = blockBufferPtr+iBlockArea;

	while(blockBufferPtr<blockBufferPtrLimit)

		*blockBufferPtr++ = TColorConvertor::RgbToMonochrome(*aColorBuffer++);

	return SetMonoPixelBlock(iBlockBuffer);

	}

//

// CPixelWriter

//

/**

 *

 * Static factory function to create CPixelWriter objects.

 *

 * @return  Pointer to a fully constructed CPixelWriter object. 

 */

CPixelWriter* CPixelWriter::NewL()

	{

	return new(ELeave) CPixelWriter;

	}

/**

 *

 * Default constructor for this class.

 */

CPixelWriter::CPixelWriter():

	iYInc(1)

	{}	

/**

 *

 * Destructor.

 */

CPixelWriter::~CPixelWriter()

	{

	Reset();

	ASSERT(iColorConv==NULL);

	ASSERT(iRgbBuffer==NULL);

	ASSERT(iIndexBuffer==NULL);

	}

/**

 *

 * @see CImageProcessor

 */

void CPixelWriter::PrepareL(CFbsBitmap& aBitmap,const TRect& aImageRect)

	{

	DoPrepareL(aBitmap,aImageRect,NULL);

	}

/**

 *

 * @see CImageProcessor

 */

void CPixelWriter::PrepareL(CFbsBitmap& aBitmap,const TRect& aImageRect,const TSize& aRgbBlockSize)

	{

	DoPrepareL(aBitmap,aImageRect,&aRgbBlockSize);

	}

/**

 *

 * @see CImageProcessor.

 */

void CPixelWriter::SetYPosIncrement(TInt aYInc)

	{

	iYInc = aYInc - iNumberOfScanlinesToSkip;

	}

/**

 *

 * @see CImageProcessor.

 */

void CPixelWriter::SetLineRepeat(TInt aLineRepeat)

	{

	ASSERT(aLineRepeat>=0);

	iLineRepeat = aLineRepeat;

	}

/**

 *

 * @see CImageProcessor.

 */

void CPixelWriter::SetPixelPadding(TInt aNumberOfPixels)

	{

	iPixelPadding = aNumberOfPixels;

	}

/**

 *

 * @see CImageProcessor.

 */

TBool CPixelWriter::SetPixel(TRgb aColor)

	{

	*iRgbBufferPtr++ = aColor;

	if (iRgbBufferPtr == iRgbBufferPtrLimit)

		return FlushPixels();

	return EFalse;

	}

/**

 *

 * @see CImageProcessor.

 */

TBool CPixelWriter::SetPixelRun(TRgb aColor,TInt aCount)

	{

	while(aCount)

		{

		TRgb* ptr = iRgbBufferPtr;

		TRgb* limit = ptr+aCount;

		if(limit>iRgbBufferPtrLimit)

			limit = iRgbBufferPtrLimit;

		TInt n = limit-ptr;

		aCount -= n;

		if(n&1)

			*ptr++ = aColor;

		if(n&2)

			{

			*ptr++ = aColor;

			*ptr++ = aColor;

			}

		if(n&4)

			{

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			}

		while(ptr<limit)

			{

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			*ptr++ = aColor;

			}

		iRgbBufferPtr = ptr;

		if(ptr!=iRgbBufferPtrLimit)

			break;

		if(FlushPixels())

			return ETrue;

		}

	return EFalse;

	}

/**

 *

 * @see CImageProcessor.

 */

TBool CPixelWriter::SetPixels(TRgb* aColorBuffer, TInt aBufferLength)

	{

	if (aBufferLength >= KPixelWriterBufferThreeQuarter)

		{

		TRgb* rgbBuffer = iRgbBuffer;

		if (iRgbBufferPtr != rgbBuffer) 

			{

			// flush rest of the pixels 

			if(FlushPixels())

				{

				return ETrue;

				}

			}

		// use external buffer without copying data

		TBool rValue = EFalse;

		while (aBufferLength && !rValue)

			{

			TInt bufferLength = (aBufferLength>KPixelWriterBufferSize)?KPixelWriterBufferSize:aBufferLength;

			iRgbBuffer = aColorBuffer;

			iRgbBufferPtr = aColorBuffer+bufferLength;

			iRgbBufferPtrLimit = aColorBuffer+bufferLength;

			rValue = FlushPixels();

			aBufferLength -= bufferLength;

			aColorBuffer += bufferLength;

			}

		// restore pointers to inner buffer

		iRgbBuffer = rgbBuffer;

		iRgbBufferPtr = rgbBuffer;

		iRgbBufferPtrLimit = rgbBuffer+KPixelWriterBufferSize;

		return rValue;

		}

	while(aBufferLength)

		{

		TRgb* ptr = iRgbBufferPtr;

		TRgb* limit = ptr+aBufferLength;

		if(limit>iRgbBufferPtrLimit)

			limit = iRgbBufferPtrLimit;

		TInt n = limit-ptr;

		aBufferLength -= n;

		if(n&1)

			*ptr++ = *aColorBuffer++;

		if(n&2)

			{

			*ptr++ = *aColorBuffer++;

			*ptr++ = *aColorBuffer++;

			}

		while(ptr<limit)

			{

			*ptr++ = *aColorBuffer++;

			*ptr++ = *aColorBuffer++;