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

#include "ImageClientMain.h"

#include "MBMCodec.h"

_LIT(KMBMPanicCategory, "MBMConvertPlugin");

// Global panic function

GLDEF_C void Panic(TIclPanic aError)

	{

	User::Panic(KMBMPanicCategory, aError);

	}

// CMbmReadCodec

CMbmReadCodec::CMbmReadCodec(TUint32 aMbmRootStreamOffset)

:iMbmRootStreamOffset(aMbmRootStreamOffset)

	{

	}

CMbmReadCodec::~CMbmReadCodec()

	{

	delete iCodecProc;

	}

CMbmReadCodec* CMbmReadCodec::NewL(TUint32 aMbmRootStreamOffset)

{

	CMbmReadCodec* self = new(ELeave) CMbmReadCodec(aMbmRootStreamOffset);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

}

TDisplayMode CMbmReadCodec::DisplayModeL(TInt aBitsPerPixel, TUint32 aFlags)

	{	

	if (aFlags & TFrameInfo::EColor)

		{

		switch (aBitsPerPixel)

			{

			case 4:

				return EColor16;

			case 8:

				return EColor256;

			case 12:

				return EColor4K;

			case 16:

				return EColor64K;

			case 24:

				return EColor16M;

			case 32:	

				if(aFlags & TFrameInfo::EAlphaChannel)

					{

					return EColor16MA;	

					}

				else

					{

					return EColor16MU;

					}

			default:

				User::Leave(KErrNotSupported);

			}

		}

	else

		{

		switch (aBitsPerPixel)

			{

			case 1:

				return EGray2;

			case 2:

				return EGray4;

			case 4:

				return EGray16;

			case 8:

				return EGray256;

			default:

				User::Leave(KErrNotSupported);

			}

		}

	return ENone;

	}

void CMbmReadCodec::InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, TBool aDisableErrorDiffusion, CFbsBitmap& aFrame, CFbsBitmap* /*aFrameMask*/)

	{

	iFrameInfo = &aFrameInfo;

	iFrameData = STATIC_CAST(TMbmDecodeData*, aFrameImageData.GetFrameData(0));

 	iCompressed = iFrameData->iCompressed;

	iByteLength = iFrameData->iImageDataSizeInBytes;

	TPoint& pos = Pos();

	pos.SetXY(0,0);

	TSize originalSize(iFrameInfo->iFrameCoordsInPixels.Size());

	TDisplayMode displayMode = DisplayModeL(iFrameInfo->iBitsPerPixel,iFrameInfo->iFlags);

	const TSize destinationSize(aFrame.SizeInPixels());

	TInt reductionFactor = ReductionFactor(originalSize, destinationSize);

	CImageProcessor* imageProc = ImageProcessorUtility::NewImageProcessorL(aFrame, reductionFactor, displayMode, aDisableErrorDiffusion);

	SetImageProcessor(imageProc);

	imageProc->PrepareL(aFrame,originalSize);

	TInt scanLinePixels = ScanLinePixels(originalSize.iWidth);

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

	SetCodecProcessorL();

	ClearBitmapL(aFrame, KRgbWhite);

		// clear in case of streamed partial decodes

	}

void CMbmReadCodec::InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& aFrameImageData)

	{

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

	iFrameInfo = &aFrameSettings;

	iImageData = &aFrameImageData;

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrameHeader);

	}

TFrameState CMbmReadCodec::ProcessFrameHeaderL(TBufPtr8& aData)

	{

	iStartDataPtr = CONST_CAST(TUint8*,aData.Ptr());

	iDataPtr = iStartDataPtr;

	iDataPtrLimit = iStartDataPtr + aData.Length();

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

		{

		if(iFrameDataRemaining <= aData.Length())

			iNumberOfFrames++;

		else

			{

			iMbmRootStreamOffset -= aData.Length();

			iFrameDataRemaining -= aData.Length();

			aData.Shift(aData.Length());

			return EFrameIncomplete;

			}

		if ((iMbmRootStreamOffset-iFrameDataRemaining) == 0)

			{

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

			return EFrameComplete;

			}

		else if ((iMbmRootStreamOffset - iFrameDataRemaining) < KMbmInfoHeaderSize)

			{

			//Bitmap StreamLength is too short to continue processing. 

			User::Leave(KErrCorrupt);

			}

		else

			{

			aData.Shift(iFrameDataRemaining);

			iMbmRootStreamOffset -= iFrameDataRemaining;

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

			return EFrameIncomplete;

			}

		}

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

		{

		if (aData.Length()<KMbmInfoHeaderSize)

			User::Leave(KErrUnderflow);

		TMbmDecodeData* mbmDecodeData = new(ELeave)TMbmDecodeData;

		CleanupStack::PushL(mbmDecodeData);

		User::LeaveIfError(iImageData->AppendFrameData(mbmDecodeData));

		CleanupStack::Pop(); // mbmImageData

		SEpocBitmapHeader header;

		RDesReadStream stream;

		stream.Open(aData);

		CleanupClosePushL(stream);

		header.iBitmapSize=stream.ReadInt32L();

		header.iStructSize=stream.ReadInt32L();

		if (header.iStructSize!=sizeof(SEpocBitmapHeader)) User::Leave(KErrCorrupt);

		header.iSizeInPixels.iWidth=stream.ReadInt32L();

		header.iSizeInPixels.iHeight=stream.ReadInt32L();

		header.iSizeInTwips.iWidth=stream.ReadInt32L();

		header.iSizeInTwips.iHeight=stream.ReadInt32L();

		header.iBitsPerPixel=stream.ReadInt32L();

		header.iColor=stream.ReadUint32L();

		header.iPaletteEntries=stream.ReadInt32L();

		header.iCompression=(TBitmapfileCompression)stream.ReadUint32L();

		CleanupStack::PopAndDestroy(); //stream

		if (header.iBitmapSize<KMbmInfoHeaderSize)

			User::Leave(KErrCorrupt);

		iFrameDataRemaining = header.iBitmapSize - KMbmInfoHeaderSize;

		if (iMbmRootStreamOffset<KMbmInfoHeaderSize)

			User::Leave(KErrCorrupt);

		iMbmRootStreamOffset -= KMbmInfoHeaderSize;

		TInt frameDataOffset = iFrameInfo->FrameDataOffset();

		iFrameInfo->SetFrameDataOffset(frameDataOffset + KMbmInfoHeaderSize);

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

		iFrameInfo->iOverallSizeInPixels = header.iSizeInPixels;

		iFrameInfo->iFrameSizeInTwips = header.iSizeInTwips;

		iFrameInfo->iBitsPerPixel = header.iBitsPerPixel;

		iFrameInfo->iDelay = 0;

		iFrameInfo->iFlags = TFrameInfo::ECanDither;

		switch(header.iColor)

			{

			case SEpocBitmapHeader::ENoColor:

				break;

			case SEpocBitmapHeader::EColor:

				iFrameInfo->iFlags |= TFrameInfo::EColor;

				break;

			case SEpocBitmapHeader::EColorAlpha:

				iFrameInfo->iFlags |= TFrameInfo::EColor;

				iFrameInfo->iFlags |= TFrameInfo::ETransparencyPossible;

				iFrameInfo->iFlags |= TFrameInfo::EAlphaChannel;

				break;

			default:

				User::Leave(KErrNotSupported);

			}

		mbmDecodeData->iCompressed = header.iCompression;

		mbmDecodeData->iImageDataSizeInBytes = header.iBitmapSize - header.iStructSize;

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

			iFrameInfo->iFrameSizeInTwips.iWidth < 0 || iFrameInfo->iFrameSizeInTwips.iHeight < 0 ||

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

			iFrameInfo->iBitsPerPixel == 4 || iFrameInfo->iBitsPerPixel == 8 || 

			iFrameInfo->iBitsPerPixel == 12 || iFrameInfo->iBitsPerPixel == 16 || 

			iFrameInfo->iBitsPerPixel == 24 || iFrameInfo->iBitsPerPixel == 32))

			User::Leave(KErrCorrupt);

		switch (iFrameInfo->iBitsPerPixel)

			{

		case 1:

			iFrameInfo->iFrameDisplayMode = EGray2;

			break;

		case 2:

			iFrameInfo->iFrameDisplayMode = EGray4;

			break;

		case 4:

			iFrameInfo->iFrameDisplayMode = (iFrameInfo->iFlags & TFrameInfo::EColor) ? EColor16 : EGray16;

			break;

		case 8:

			iFrameInfo->iFrameDisplayMode = (iFrameInfo->iFlags & TFrameInfo::EColor) ? EColor256 : EGray256;

			break;

		case 12:

			iFrameInfo->iFrameDisplayMode = EColor4K;

			break;

		case 16:

			iFrameInfo->iFrameDisplayMode = EColor64K;

			break;

		case 24:

			iFrameInfo->iFrameDisplayMode = EColor16M;

			break;

		case 32:

			if(iFrameInfo->iFlags & TFrameInfo::ETransparencyPossible && iFrameInfo->iFlags & TFrameInfo::EAlphaChannel)

				{

				iFrameInfo->iFrameDisplayMode = EColor16MA;

				}

			else

				{

				iFrameInfo->iFrameDisplayMode = EColor16MU;

				}

			break;

			}

		aData.Shift(KMbmInfoHeaderSize);

		iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrame);

		}

	return EFrameIncomplete;

	}

TFrameState CMbmReadCodec::ProcessFrameL(TBufPtr8& aSrc)

	{

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

	iDataPtr = srcPtr;

	iDataPtrLimit = iDataPtr + Min(aSrc.Length(),iByteLength);

	iCodecProc->DoProcessL(iDataPtr,iDataPtrLimit);

	TInt bytesUsed = iDataPtr - srcPtr;

	aSrc.Shift(bytesUsed);

	iByteLength -= bytesUsed;

	if (iByteLength == 0)

		{

		ImageProcessor()->FlushPixels();

		delete iCodecProc;

		iCodecProc = NULL;

		return EFrameComplete;

		}

	return EFrameIncomplete;

	}

TInt CMbmReadCodec::ScanLinePixels(TInt aWidth)

	{

	switch (iFrameInfo->iBitsPerPixel)

		{

	case 1:

		return CFbsBitmap::ScanLineLength(aWidth,EGray2) << 3;

	case 2:

		return CFbsBitmap::ScanLineLength(aWidth,EGray4) << 2;

	case 4:

		return CFbsBitmap::ScanLineLength(aWidth,EGray16) << 1;

	case 8:

		return CFbsBitmap::ScanLineLength(aWidth,EGray256);

	case 12:

	case 16:

		return CFbsBitmap::ScanLineLength(aWidth,EColor64K) >> 1;

	case 24:

		return CFbsBitmap::ScanLineLength(aWidth,EColor16M) / 3;

	case 32:

		return CFbsBitmap::ScanLineLength(aWidth,EColor16MU) / 4; // for all 32bit modes

	default:

		return 0;

		}

	}

void CMbmReadCodec::SetCodecProcessorL()

	{

	delete iCodecProc;

	iCodecProc = NULL;

	const TBool color = (iFrameInfo->iFlags & TFrameInfo::EColor);

	switch (iFrameInfo->iBitsPerPixel)

		{

	case 1:

		if (iCompressed)

			iCodecProc = new(ELeave) T1BppCompressedMbmReadCodec;

		else

			iCodecProc = new(ELeave) T1BppMbmReadCodec;

		break;

	case 2:

		if (iCompressed)

			iCodecProc = new(ELeave) T2BppCompressedMbmReadCodec;

		else

			iCodecProc = new(ELeave) T2BppMbmReadCodec;

		break;

	case 4:

		if (color)

			{

			if (iCompressed)

				iCodecProc = new(ELeave) T4BppColorCompressedMbmReadCodec;

			else

				iCodecProc = new(ELeave) T4BppColorMbmReadCodec;

			}

		else

			{

			if (iCompressed)

				iCodecProc = new(ELeave) T4BppMonoCompressedMbmReadCodec;

			else

				iCodecProc = new(ELeave) T4BppMonoMbmReadCodec;

			}

		break;

	case 8:

		if (color)

			{

			if (iCompressed)

				iCodecProc = new(ELeave) T8BppColorCompressedMbmReadCodec;

			else

				iCodecProc = new(ELeave) T8BppColorMbmReadCodec;

			}

		else

			{

			if (iCompressed)

				iCodecProc = new(ELeave) T8BppMonoCompressedMbmReadCodec;

			else

				iCodecProc = new(ELeave) T8BppMonoMbmReadCodec;

			}

		break;

	case 12:

		if (iCompressed)

			iCodecProc = new(ELeave) T12BppCompressedMbmReadCodec;

		else

			iCodecProc = new(ELeave) T12BppMbmReadCodec;

		break;

	case 16:

		if (iCompressed)

			iCodecProc = new(ELeave) T16BppCompressedMbmReadCodec;

		else

			iCodecProc = new(ELeave) T16BppMbmReadCodec;

		break;

	case 24:

		if (iCompressed)

			iCodecProc = new(ELeave) T24BppCompressedMbmReadCodec;

		else

			iCodecProc = new(ELeave) T24BppMbmReadCodec;

		break;

	case 32:

		if (iCompressed)

			User::Leave(KErrNotSupported);

		else

			iCodecProc = new(ELeave) T32BppMbmReadCodec;

		break;

	default:

		User::Leave(KErrCorrupt);

		}

	iCodecProc->iImageProc = ImageProcessor();

	}

// TMbmReadCodec

void TMbmReadCodec::AddPixelRun(TRgb aColor,TInt aNumberOfPixels)

	{

	iImageProc->SetPixelRun(aColor,aNumberOfPixels);

	}

// T1BppMbmReadCodec

void T1BppMbmReadCodec::DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit)

	{

	while (aDataPtr < aDataPtrLimit)

		AddPixelValue(*aDataPtr++);

	}

void T1BppMbmReadCodec::AddPixelValue(TUint8 aValue)

	{

	iImageProc->SetPixel((aValue & 0x01) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x02) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x04) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x08) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x10) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x20) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x40) ? KRgbWhite : KRgbBlack);

	iImageProc->SetPixel((aValue & 0x80) ? KRgbWhite : KRgbBlack);

	}

// T1BppCompressedMbmReadCodec

void T1BppCompressedMbmReadCodec::DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit)

	{

	while (aDataPtr < aDataPtrLimit)

		{

		TInt8 count = *aDataPtr++;

		if (count >= 0)

			{

			if (aDataPtr >= aDataPtrLimit)

				{

				aDataPtr--;

				break;

				}

			AddPixelRun(*aDataPtr++,count + 1);

			}

		else

			{

			TUint8* tempDataPtrLimit = aDataPtr - count;

			if (tempDataPtrLimit > aDataPtrLimit)

				{

				aDataPtr--;

				break;

				}

			while (aDataPtr < tempDataPtrLimit)

				AddPixelValue(*aDataPtr++);

			}

		}

	}

void T1BppCompressedMbmReadCodec::AddPixelRun(TUint8 aValue,TInt aNumberOfValues)

	{

	TRgb color0 = (aValue & 0x01) ? KRgbWhite : KRgbBlack;

	TRgb color1 = (aValue & 0x02) ? KRgbWhite : KRgbBlack;

	TRgb color2 = (aValue & 0x04) ? KRgbWhite : KRgbBlack;

	TRgb color3 = (aValue & 0x08) ? KRgbWhite : KRgbBlack;

	TRgb color4 = (aValue & 0x10) ? KRgbWhite : KRgbBlack;

	TRgb color5 = (aValue & 0x20) ? KRgbWhite : KRgbBlack;

	TRgb color6 = (aValue & 0x40) ? KRgbWhite : KRgbBlack;

	TRgb color7 = (aValue & 0x80) ? KRgbWhite : KRgbBlack;

	for (; aNumberOfValues > 0; aNumberOfValues--)

		{

		iImageProc->SetPixel(color0);

		iImageProc->SetPixel(color1);

		iImageProc->SetPixel(color2);

		iImageProc->SetPixel(color3);

		iImageProc->SetPixel(color4);

		iImageProc->SetPixel(color5);

		iImageProc->SetPixel(color6);

		iImageProc->SetPixel(color7);

		}

	}

// T2BppMbmReadCodec

void T2BppMbmReadCodec::DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit)

	{

	while (aDataPtr < aDataPtrLimit)

		AddPixelValue(*aDataPtr++);

	}

void T2BppMbmReadCodec::AddPixelValue(TUint8 aValue)

	{

	iImageProc->SetPixel(TRgb::Gray4(aValue & 0x3));

	iImageProc->SetPixel(TRgb::Gray4((aValue >> 2) & 0x3));

	iImageProc->SetPixel(TRgb::Gray4((aValue >> 4) & 0x3));

	iImageProc->SetPixel(TRgb::Gray4((aValue >> 6) & 0x3));

	}

// T2BppCompressedMbmReadCodec

void T2BppCompressedMbmReadCodec::DoProcessL(TUint8*& aDataPtr,TUint8* aDataPtrLimit)

	{

	while (aDataPtr < aDataPtrLimit)

		{

		TInt8 count = *aDataPtr++;