// 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 "PPM1Codec.h"

#include "pluginextensionmanager.h"

const TInt KRAWBytesPerPixel = 3;

// CPpmReadCodec

CPpmReadCodec* CPpmReadCodec::NewL(CPpmDecoder& aDecoder)

	{

	CPpmReadCodec* result = new (ELeave) CPpmReadCodec(aDecoder);

	CleanupStack::PushL(result);

	result->ConstructL();

	CleanupStack::Pop(result);

	return result;

	}

CPpmReadCodec::CPpmReadCodec(CPpmDecoder& aDecoder):

	iDecoder(&aDecoder)

	{}

CPpmReadCodec::~CPpmReadCodec()

	{

	}

TFrameState CPpmReadCodec::ProcessFrameL(TBufPtr8& aSrc)

	{

	const TUint8* srcStart = aSrc.Ptr();

	iDataPtr = srcStart;

	iDataPtrLimit = srcStart + aSrc.Length();

	TInt bytesUsed = 0;

	if(!iSeekRequested)

		{

		if (iDecoder->Compressed())

			{

			DoProcessCompressed();

			bytesUsed = iDataPtr - srcStart;

			}

		else

			{

			TLex8 lex (aSrc);

			TRAPD(error, DoProcessUncompressedL(lex));

			if (error!=KErrNone && error!=KErrGeneral && error!=KErrUnderflow) // trap for insufficient data

				{

				User::Leave(error);

				}

			bytesUsed = lex.MarkedOffset();

			}

		aSrc.Shift(bytesUsed);

		}

	if (iPixelsProcessed >= iPixelsExpected)

		{

		return EFrameComplete;

		}

	if(iSeekRequested)

		{

		/*

		Move the pointer to the end of the buffer.  This is to 

		workaround a problem with the ICL framework, where if we

		choose to seek and haven't incremented the pointer, then

		it returns KErrUnderflow.  Thus, the first seek (when 

		cropping) will fail.

		*/

		TInt bytesRemainingInBuffer = Min(iNewBytePosition, iDataPtrLimit - iDataPtr);

		aSrc.Shift(bytesRemainingInBuffer);

		iNewBytePosition -= bytesRemainingInBuffer;

		iSeekRequested = EFalse;

		return EFrameIncompleteRepositionRequest;

		}

	return EFrameIncomplete;

	}

void CPpmReadCodec::Complete()

	{

	ImageProcessor()->FlushPixels(); 

	}

void CPpmReadCodec::DoProcessUncompressedL(TLex8 &aLex)

	{

	CImageProcessor*const imageProc = ImageProcessor();

	for (;;) // exit of this will be a leave

		{

		TUint rVal;

		iDecoder->SkipCommentAndWhiteSpaceL(aLex);

		ASSERT(!iDecoder->InComment());

		User::LeaveIfError(aLex.Val(rVal));

		TUint gVal;

		iDecoder->SkipCommentAndWhiteSpaceL(aLex);

		ASSERT(!iDecoder->InComment());

		User::LeaveIfError(aLex.Val(gVal));

		TUint bVal;

		iDecoder->SkipCommentAndWhiteSpaceL(aLex);

		ASSERT(!iDecoder->InComment());

		User::LeaveIfError(aLex.Val(bVal));

		TInt dataShift = iDecoder->DataShift();

		TRgb rgb (rVal<<dataShift, gVal<<dataShift, bVal<<dataShift);

		imageProc->SetPixel(rgb);

		aLex.Mark(); // show we've got this far - on error, only wind back this far.

		iPixelsProcessed += 1;

		}

	}

void CPpmReadCodec::DoProcessCompressed()

	{

	CImageProcessor*const imageProc = ImageProcessor();

	while (iDataPtr < iDataPtrLimit-2)

		{

		TUint8 rVal = iDataPtr[0];

		TUint8 gVal = iDataPtr[1];

		TUint8 bVal = iDataPtr[2];

		iDataPtr += KRAWBytesPerPixel;

		TInt dataShift = iDecoder->DataShift();

		TRgb rgb (rVal<<dataShift, gVal<<dataShift, bVal<<dataShift);

		imageProc->SetPos(iCurrentPosition);

		imageProc->SetPixel(rgb);

		iPixelsProcessed += 1;

		if(iXAxisFirst)

			{

			iCurrentPosition.iX += iXAxisIncrement;

			if(iCurrentPosition.iX == iEndPosition.iX)

				{

				iCurrentPosition.iX = iStartPosition.iX;

				iCurrentPosition.iY += iYAxisIncrement;

				if(iExtensionManager->ClippingRectExtensionRequested())

					{

					// Clipping is required, so need to skip position in buffer

					iSeekRequested = ETrue;

					iNewBytePosition = iFrameInfo->iOverallSizeInPixels.iWidth - iExtensionManager->ClippingRect().Size().iWidth;

					iNewBytePosition *= KRAWBytesPerPixel;

					break;

					}

				}

			}

		else

			{

			iCurrentPosition.iY += iYAxisIncrement;

			if(iCurrentPosition.iY == iEndPosition.iY)

				{

				iCurrentPosition.iY = iStartPosition.iY;

				iCurrentPosition.iX += iXAxisIncrement;

				if(iExtensionManager->ClippingRectExtensionRequested())

					{

					// Clipping is required, so need to skip position in buffer

					iSeekRequested = ETrue;

					iNewBytePosition = iFrameInfo->iOverallSizeInPixels.iWidth - iExtensionManager->ClippingRect().Size().iWidth;

					iNewBytePosition *= KRAWBytesPerPixel;

					break;

					}

				}

			}

		}

	}

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

	{

	ASSERT(iFrameInfo);

	ASSERT(iExtensionManager);

	/*

	This function is used by both compressed and uncompressed format, although some of the

	calls aren't stricly necessary for the uncompressed format (since extensions are not

	supported, except for the GetDestinationSize() call).

	*/

	User::LeaveIfError(ValidateDestinationSize(aFrame.SizeInPixels()));

	TSize finalSize = iExtensionManager->ClippingRectExtensionRequested() ?

					  iExtensionManager->ClippingRect().Size() : iFrameInfo->iOverallSizeInPixels;

	if(iExtensionManager->DimensionsSwapped())

		{

		finalSize.SetSize(finalSize.iHeight, finalSize.iWidth);

		}

	TInt scalingCoefficient = ScalingCoefficientL(finalSize, aFrame.SizeInPixels());

	TInt reductionFactor = CPluginExtensionManager::ConvertScalingCoeffToReductionFactor(scalingCoefficient);

	CImageProcessorExtension* imageProc = 

		ImageProcessorUtility::NewImageProcessorExtensionL(aFrame, reductionFactor, iFrameInfo->iFrameDisplayMode, aDisableErrorDiffusion);

	SetImageProcessor(imageProc);

	iExtensionManager->TransferExtensionDataL(imageProc);

	// Pass in full size of image or clip rect

	imageProc->PrepareL(aFrame, finalSize);

	// Set up member variables if Operations have been requested

	SetOperationData(finalSize);

	ClearBitmapL(aFrame, KRgbWhite);

		// do something sensible for partial streamed decodes

	iPixelsProcessed = 0;

	iPixelsExpected = finalSize.iWidth * finalSize.iHeight;

	// Determine how many pixels to skip on the Y axis of the original, if any

	TInt pixelsToSkip = iFrameInfo->iFrameCoordsInPixels.iBr.iX * iExtensionManager->ClippingRect().iTl.iY;

	// Add X axis pixels on the left side of the crop rect, if any

	pixelsToSkip += iExtensionManager->ClippingRect().iTl.iX - iFrameInfo->iFrameCoordsInPixels.iTl.iX;

	iNewBytePosition = pixelsToSkip*KRAWBytesPerPixel;

	iSeekRequested = iNewBytePosition > 0 ? ETrue : EFalse;	

	iDecoder->SetInComment(EFalse);

	}

void CPpmReadCodec::InitFrameHeader(TFrameInfo& aFrameInfo, CFrameImageData& /*aFrameData*/)

	{

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

	iFrameInfo = &aFrameInfo;

	aFrameInfo.SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrameHeader);

	}

TFrameState CPpmReadCodec::ProcessFrameHeaderL(TBufPtr8&/* aData*/)

	{

	ASSERT(iFrameInfo);

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

	return EFrameComplete;

	}

void CPpmReadCodec::GetNewDataPosition(TInt &aPosition, TInt &/*aLength*/)

	{

	aPosition += iNewBytePosition;

	}

void CPpmReadCodec::SetExtensionManager(CPluginExtensionManager* aExtensionManager)

	{

	// Is owned by the plugin, not this codec

	iExtensionManager = aExtensionManager;

	}

TInt CPpmReadCodec::ValidateDestinationSize(const TSize& aDestSize) const

	{

	ASSERT(iExtensionManager);

	TInt err = KErrNone;

	if(iExtensionManager->ScalerExtensionRequested())

		{

		TSize destSizeCheck = iFrameInfo->iOverallSizeInPixels;

		err = iExtensionManager->GetDestinationSize(destSizeCheck);

		if(err == KErrNone)

			{

			// Mandatory check that the destination size matches the calculated size

			if(destSizeCheck != aDestSize)

				{

				err = KErrArgument;

				}	

			}

		}

	return err;

	}

TInt CPpmReadCodec::ScalingCoefficientL(const TSize& aDestinationSize, const TSize& aFrameSize) const

	{

	ASSERT(iExtensionManager);

	TInt scalingCoefficient = -1; // initialise to full size

	if(iExtensionManager->ScalerExtensionRequested())

		{

		// Explicit scaling

		User::LeaveIfError(iExtensionManager->GetScalingCoefficient(scalingCoefficient, &aDestinationSize));

		}

	else

		{

		// Implicit scaling

		scalingCoefficient = ScalingCoefficient(aDestinationSize, aFrameSize);

		}

	return scalingCoefficient;

	}

void CPpmReadCodec::SetOperationData(const TRect& aDestinationBitmap)

	{

	ASSERT(iExtensionManager);

	ASSERT(!aDestinationBitmap.IsEmpty());

	ASSERT(aDestinationBitmap.IsNormalized());

	/*

	Note that iStartPosition is the starting point and so needs to

	be INSIDE the TRect, whereas iEndPosition is the end point and thus

	lies diagonally opposite the start point, and OUTSIDE the TRect.

		-----------------

		|tlo|   |   |tro

		-----------------

		|   |tli|tri|   |

		-----------------

		|   |bli|bri|   |

		-----------------

		|blo|   |   |bro|

		-----------------

		tlo = top left outside image

		tro = top right outside image

		blo = bottom left outside image

		bro = bottom right outside image (i.e. iBr)

		tli = top left inside image (i.e. iTl)

		tri = top right inside image

		bli = bottom left inside image

		bri = bottom right inside image

	*/

	TPoint tlOutsideImageRegion(aDestinationBitmap.iTl.iX - 1, aDestinationBitmap.iTl.iY - 1);

	TPoint trOutsideImageRegion(aDestinationBitmap.iBr.iX, aDestinationBitmap.iTl.iY - 1);

	TPoint blOutsideImageRegion(aDestinationBitmap.iTl.iX - 1, aDestinationBitmap.iBr.iY);

	TPoint brOutsideImageRegion(aDestinationBitmap.iBr.iX, aDestinationBitmap.iBr.iY);	

	TPoint tlInsideImageRegion(aDestinationBitmap.iTl.iX, aDestinationBitmap.iTl.iY);

	TPoint trInsideImageRegion(aDestinationBitmap.iBr.iX - 1, aDestinationBitmap.iTl.iY);

	TPoint blInsideImageRegion(aDestinationBitmap.iTl.iX, aDestinationBitmap.iBr.iY - 1);

	TPoint brInsideImageRegion(aDestinationBitmap.iBr.iX - 1, aDestinationBitmap.iBr.iY - 1);

	switch(iExtensionManager->Operation())

		{

		case EDecodeNormal:

			iStartPosition = tlInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = brOutsideImageRegion;

			iXAxisIncrement = 1;

			iYAxisIncrement = 1;

			iXAxisFirst = ETrue;

			break;

		case EDecodeRotate90:

			iStartPosition = trInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = blOutsideImageRegion;

			iXAxisIncrement = -1;

			iYAxisIncrement = 1;

			iXAxisFirst = EFalse;

			break;

		case EDecodeRotate180:

			iStartPosition = brInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = tlOutsideImageRegion;

			iXAxisIncrement = -1;

			iYAxisIncrement = -1;

			iXAxisFirst = ETrue;

			break;

		case EDecodeRotate270:

			iStartPosition = blInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = trOutsideImageRegion;

			iXAxisIncrement = 1;

			iYAxisIncrement = -1;

			iXAxisFirst = EFalse;

			break;

		case EDecodeHorizontalFlip:

			iStartPosition = blInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = trOutsideImageRegion;

			iXAxisIncrement = 1;

			iYAxisIncrement = -1;

			iXAxisFirst = ETrue;

			break;

		case EDecodeHorizontalFlipRotate90:

			iStartPosition = tlInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = brOutsideImageRegion;

			iXAxisIncrement = 1;

			iYAxisIncrement = 1;

			iXAxisFirst = EFalse;

			break;

		case EDecodeVerticalFlip:

			iStartPosition = trInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = blOutsideImageRegion;

			iXAxisIncrement = -1;

			iYAxisIncrement = 1;

			iXAxisFirst = ETrue;

			break;

		case EDecodeVerticalFlipRotate90:

			iStartPosition = brInsideImageRegion;

			iCurrentPosition = iStartPosition;

			iEndPosition = tlOutsideImageRegion;

			iXAxisIncrement = -1;

			iYAxisIncrement = -1;

			iXAxisFirst = EFalse;

			break;

		default:

			{

			ASSERT(EFalse);

			}

		}

	}

// CPpm1WriteCodec

const TInt KMaxColourValue = 255;

CPpm1WriteCodec::CPpm1WriteCodec()

	{}

CPpm1WriteCodec::~CPpm1WriteCodec()

	{}

void CPpm1WriteCodec::ConstructL()

	{

	CImageWriteCodec::ConstructL();

	}

CPpm1WriteCodec* CPpm1WriteCodec::NewL()

	{

	CPpm1WriteCodec* result = new (ELeave) CPpm1WriteCodec;

	CleanupStack::PushL(result);

	result->ConstructL();

	CleanupStack::Pop(result);

	return result;

	}

void CPpm1WriteCodec::InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource)

	{

	SetSource(&aSource);

	iDestStartPtr = const_cast<TUint8*>(aDst.Ptr());

	iDestPtr = iDestStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength();

	TSize size = aSource.SizeInPixels();

	iSourceRect = TRect(size);

	iPos.SetXY(0,0);

	TBuf8<256> header; // set up header in buffer

	header.Zero();

	// now the standard header lines

	_LIT8(KMagicHeader, "P6\n");

	header.AppendFormat(KMagicHeader); // ppm magic for compressed

	_LIT8(KSizeHeader, "%d %d\n");

	header.AppendFormat(KSizeHeader, size.iWidth, size.iHeight);

	_LIT8(KMaxValueHeader, "%d\n");

	header.AppendFormat(KMaxValueHeader, KMaxColourValue);

	TInt headerSize = header.Length();

	aDst.Copy(header);

	iDestPtr+=headerSize;

	ASSERT(iDestPtr < iDestPtrLimit); // should always be true

	}

TFrameState CPpm1WriteCodec::ProcessFrameL(TBufPtr8& aDst)

	{

	//Setup buffer to use all available space

	TUint8* destStartPtr = CONST_CAST(TUint8*,aDst.Ptr());

	iDestPtr = destStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength();

	DoProcessL(*Source());

	aDst.SetLength(iDestPtr - destStartPtr);

	// If processed all pixels

	if (iPos.iY < iSourceRect.iTl.iY)

		{

		return EFrameComplete;

		}

	return EFrameIncomplete;

	}

void CPpm1WriteCodec::DoProcessL(const CFbsBitmap& aFrame)

	{

	TUint8* safeDestPtrLimit = iDestPtrLimit - 2;

	while (iDestPtr < safeDestPtrLimit)

		{

		if (iPos.iY >= iSourceRect.iBr.iY)

			{

			break;

			}

		TInt scanLength = Min(iSourceRect.iBr.iX - iPos.iX, (iDestPtrLimit - iDestPtr) / 3);

		TInt dstLength = scanLength * 3;

		TPtr8 dstBuf(iDestPtr, dstLength, dstLength);

		aFrame.GetScanLine(dstBuf, iPos, scanLength, EColor16M);

		// this comes out in order BGR, so switch

		SwitchRGB(dstBuf);

		iPos.iX += scanLength;

		iDestPtr += dstLength;

		if (iPos.iX == iSourceRect.iBr.iX)

			{

			iPos.iX = iSourceRect.iTl.iX;

			iPos.iY++;

			}

		}

	}

// Assume original has pixels with BGR in order - switch to RGB

void CPpm1WriteCodec::SwitchRGB(TDes8 &aBuf)

	{

	TUint8* buf = const_cast<TUint8*>(aBuf.Ptr());

	TUint8* bufMax = buf + aBuf.Length();

	while (buf<bufMax)

		{

		TUint8 b = buf[0];

		TUint8 g = buf[1];

		TUint8 r = buf[2];

		buf[0] = r;

		buf[1] = g;

		buf[2] = b;