// 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 <fbs.h>

#include "ICOCodec.h"

#include "icomaskprocessor.h"

// Constants.

const TInt KIcoInfoHeaderSize = 40;

const TInt KRgbQuadSize = 4;

const TInt KFullyOpaque = 0x7FFFFFFF;

const TInt KFullyTransparent = 0x00000000;

const TUint KBlack = 0xFF000000;

const TUint KWhite = 0xFFFFFFFF;

// CIcoReadCodec

CIcoReadCodec::CIcoReadCodec(TInt aIconHeadersToProcess)

	: iIconHeadersToProcess(aIconHeadersToProcess)

	{}

CIcoReadCodec::~CIcoReadCodec()

	{

	}

CIcoReadCodec* CIcoReadCodec::NewL(TInt aIconHeadersToProcess)

{

	CIcoReadCodec* self = new(ELeave) CIcoReadCodec(aIconHeadersToProcess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

}

void CIcoReadCodec::InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& /* aFrameImageData */)

	{

	ASSERT(aFrameSettings.CurrentFrameState() == TFrameInfo::EFrameInfoUninitialised);

	iFrameInfo= &aFrameSettings;

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrameHeader);

	}

TFrameState CIcoReadCodec::ProcessFrameHeaderL(TBufPtr8& aData)

	{

 	if (iFrameInfo->CurrentFrameState() == TFrameInfo::EFrameInfoProcessingFrame)

		{

		if(aData.Length()>=iImageDataBytes)

			{

			aData.Shift(iImageDataBytes);

			iImageDataBytes = 0;

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

			if ((--iIconHeadersToProcess) == 0)

				return EFrameComplete;

			}

		else

			{

			iImageDataBytes -= aData.Length();

			aData.Shift(aData.Length()); 

			}

		}

	if (iFrameInfo->CurrentFrameState() == TFrameInfo::EFrameInfoProcessingFrameHeader)

		{ // If processing of previous frame info complete or if its the first frame.

		if (aData.Length() < KIcoInfoHeaderSize)

			User::Leave(KErrUnderflow);

		const TUint8* data = STATIC_CAST(const TUint8*, aData.Ptr());

		const TInt width = data[4] + (data[5] << 8) + (data[6] << 16) + (data[7] << 24);

		const TInt height = (data[8] + (data[9] << 8) + (data[10] << 16) + (data[11] << 24))/2;

		if(width <= 0 || height <= 0)

			User::Leave(KErrCorrupt);		

		iFrameInfo->iBitsPerPixel = data[14] + (data[15] << 8);

		const TInt colors = 1 << iFrameInfo->iBitsPerPixel;

		// Calculate image size. (Pixels)

		iFrameInfo->iOverallSizeInPixels.SetSize(width, height);

		// Calculate image size. (Bytes)

		// XOR image.

		iImageDataBytes = (width*iFrameInfo->iBitsPerPixel + 31)/32;

		if(iImageDataBytes <= 0) //overflow

			User::Leave(KErrCorrupt);		

		// AND image.

		iImageDataBytes += (width + 31)/32;

		if(iImageDataBytes <= 0) //overflow

			User::Leave(KErrCorrupt);		

		iImageDataBytes *= 4*height;

		if(iImageDataBytes <= 0) //overflow

			User::Leave(KErrCorrupt);		

		// Include the palette as well.

		iImageDataBytes += colors*KRgbQuadSize;

		if(iImageDataBytes <= 0) //overflow

			User::Leave(KErrCorrupt);		

		iFrameInfo->iFrameCoordsInPixels.SetRect(TPoint(0,0), iFrameInfo->iOverallSizeInPixels);

		iFrameInfo->iFrameSizeInTwips.SetSize(0, 0);

		iFrameInfo->iDelay = 0;

		iFrameInfo->iFlags |= TFrameInfo::ETransparencyPossible | TFrameInfo::EPartialDecodeInvalid;

		if (iFrameInfo->iFrameCoordsInPixels.iBr.iX < 0 || iFrameInfo->iFrameCoordsInPixels.iBr.iY < 0 ||

			!(iFrameInfo->iBitsPerPixel == 1 || iFrameInfo->iBitsPerPixel == 4 ||

			iFrameInfo->iBitsPerPixel == 8))

			User::Leave(KErrCorrupt);

		if (iFrameInfo->iBitsPerPixel > 1)

			iFrameInfo->iFlags |= TFrameInfo::EColor;

		switch (iFrameInfo->iBitsPerPixel)

			{

			case 1:

				iFrameInfo->iFrameDisplayMode = EGray2;

				break;

			case 4:

				iFrameInfo->iFrameDisplayMode = EColor16;

				iFrameInfo->iFlags |= TFrameInfo::EColor;

				break;

			case 8:

				iFrameInfo->iFrameDisplayMode = EColor256;

				iFrameInfo->iFlags |= TFrameInfo::EColor;

				break;

			}

		aData.Shift(KIcoInfoHeaderSize);

		TInt frameDataOffset = iFrameInfo->FrameDataOffset();

		iFrameInfo->SetFrameDataOffset(frameDataOffset + KIcoInfoHeaderSize);

		iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrame);

		}

	return EFrameIncomplete;

	}

TFrameState CIcoReadCodec::ProcessFrameL(TBufPtr8& aSrc)

	{	

	if (iNewFrame)

		{

		// Extract the palette.

		TInt colors = 1 << iFrameInfo->iBitsPerPixel;

		if (aSrc.Length()<(colors*KRgbQuadSize))

			return EFrameIncomplete;

		const TUint8* aSrcPtr = aSrc.Ptr();

		TInt baseIndex;

		for (TInt paletteIndex = 0; paletteIndex < colors; paletteIndex++)

			{

			baseIndex = KRgbQuadSize*paletteIndex;

			iPalette[paletteIndex] = TRgb(aSrcPtr[baseIndex+2],aSrcPtr[baseIndex+1],aSrcPtr[baseIndex]);

			}

		aSrc.Shift(colors*KRgbQuadSize);

		iNewFrame = EFalse;

		}

	if (aSrc.Length() == 0)

		return EFrameIncomplete;

	TUint8* srcStart = CONST_CAST(TUint8*,aSrc.Ptr());

	iDataPtr = srcStart;

	iDataPtrLimit = srcStart + aSrc.Length();

	DoProcessL();

	TInt bytesUsed = iDataPtr - srcStart;

	aSrc.Shift(bytesUsed);

	ASSERT(iBmpBytesExpected>=0); // not clear if value can be negative - if it does occur, need to think about it

	if (iBmpBytesExpected > 0)

		{

		const TInt bmpBytesUsed = Min(bytesUsed, iBmpBytesExpected);

		iBmpBytesExpected -= bmpBytesUsed;

		bytesUsed -= bmpBytesUsed;

		}

	CImageProcessor*const imageProc = ImageProcessor();

	CImageProcessor*const maskProc = MaskProcessor();

	if (bytesUsed > 0 && maskProc)

		{

		const TInt maskBytesUsed = Min(bytesUsed, iMaskBytesExpected);

		iMaskBytesExpected -= maskBytesUsed;

		}

	if ((!maskProc && iBmpBytesExpected <= 0) || (maskProc && iMaskBytesExpected <= 0))

		{

		imageProc->FlushPixels();

		if (maskProc)

			maskProc->FlushPixels();

		iNewFrame = ETrue;

		Pos().SetXY(0,0);

		return EFrameComplete;

		}

	return EFrameIncomplete;

	}

void CIcoReadCodec::InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& /*aFrameImageData*/, TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, CFbsBitmap* aDestinationMask)

	{

	iFrameInfo= &aFrameInfo;

	CFbsBitmap& newFrame = aDestination;

	TSize& originalSize = iFrameInfo->iOverallSizeInPixels;

	Pos().iY = originalSize.iHeight - 1;

	const TDisplayMode dispMode = (iFrameInfo->iBitsPerPixel == 1) ? EGray2 : EColor256;

	const TSize destinationSize(aDestination.SizeInPixels());

	TInt reductionFactor = ReductionFactor(originalSize, destinationSize);

	CImageProcessor* imageProc = ImageProcessorUtility::NewImageProcessorL(aDestination, reductionFactor, dispMode, aDisableErrorDiffusion);

	SetImageProcessor(imageProc);

	imageProc->PrepareL(newFrame, originalSize);

	imageProc->SetPos(TPoint(0, originalSize.iHeight - 1));

	imageProc->SetYPosIncrement(-1);

	CImageProcessor* maskProc = NULL;

	SetMaskProcessor(NULL);

	if (aDestinationMask)

		{

		CFbsBitmap& newMaskFrame = *aDestinationMask;

		maskProc = ImageProcessorUtility::NewImageProcessorL(newMaskFrame, originalSize, EGray2, aDisableErrorDiffusion);

		SetMaskProcessor(maskProc);

		maskProc->PrepareL(newMaskFrame, originalSize);

		}

	else if (newFrame.DisplayMode() == EColor16MA)

		{

		// 16MA dest and no mask - special case

		maskProc = CIcoMaskProcessor::NewL(reductionFactor);

		SetMaskProcessor(maskProc);

		maskProc->PrepareL(newFrame, originalSize); // uses destination bitmap

		}

	if(maskProc)

		{

		maskProc->SetPos(TPoint(0,originalSize.iHeight - 1));

		maskProc->SetYPosIncrement(-1);

		const TInt maskWidth = (originalSize.iWidth + 31) & ~31; // round up to 32-byte boundary

		maskProc->SetPixelPadding(maskWidth - originalSize.iWidth);

		iMaskBytesExpected = (maskWidth * originalSize.iHeight) / 8;

		}

	const TInt actualWidth = (((originalSize.iWidth * iFrameInfo->iBitsPerPixel) + 31) & ~31) / iFrameInfo->iBitsPerPixel; // round up to 32-byte boundary

	imageProc->SetPixelPadding(actualWidth - originalSize.iWidth);

	iBmpBytesExpected = (actualWidth * originalSize.iHeight * iFrameInfo->iBitsPerPixel) / 8; // bits are packed into bytes

	iNewFrame =ETrue;

	}

void CIcoReadCodec::DoProcessL()

	{

	const TUint8* bmpDataPtrLimit = Min(iDataPtrLimit, iDataPtr + iBmpBytesExpected);

	CImageProcessor*const imageProc = ImageProcessor();

	switch (iFrameInfo->iBitsPerPixel)

		{

	case 1:

		while (iDataPtr < bmpDataPtrLimit)

			{

			TUint8 value = *iDataPtr++;

			// code will compare value with successive masks 0x80, 0x80 etc downto but not including 

			for (TUint mask=0x80; mask!=0; mask >>= 1)

				imageProc->SetPixel((value & mask) ? iPalette[1] : iPalette[0]);

			}

		break;

	case 4:

		while (iDataPtr < bmpDataPtrLimit)

			{

			TUint8 value = *iDataPtr++;

			imageProc->SetPixel(iPalette[value >> 4]);

			imageProc->SetPixel(iPalette[value & 0x0f]);

			}

		break;

	case 8:

		while (iDataPtr < bmpDataPtrLimit)

			imageProc->SetPixel(iPalette[*iDataPtr++]);

		break;

	default:

		User::Leave(KErrCorrupt);

		break;

		}

	CImageProcessor*const maskProc = MaskProcessor();

	if (maskProc)

		{

		// force a flush

		imageProc->FlushPixels();

		const TUint8* maskDataPtrLimit = Min(iDataPtrLimit, iDataPtr + iMaskBytesExpected);

		while (iDataPtr < maskDataPtrLimit)

			{

			TUint8 value = *iDataPtr++;

			// code will compare value with successive masks 0x80, 0x80 etc downto but not including 

			for (TUint mask=0x80; mask!=0; mask >>= 1)

				{

				maskProc->SetPixel((value & mask) ? TRgb(KBlack, KFullyTransparent) : TRgb(KWhite, KFullyOpaque));				

				}

			}

		}

	}