// Copyright (c) 1997-2010 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:

// Licensed under US Patent No 4,558,302 and foreign counterparts

// 

//

// CGifWriteCodec::TableEntry() is based on compress_byte() from wrgif.c

// in the IJG V6 code, Copyright (C) 1991-1997, Thomas G. Lane.

#include <fbs.h>

#include "GIFcodec.h"

#include "rawimageprocessor.h"

const TInt KPass2StartLine = 4;

const TInt KPass3StartLine = 2;

const TInt KPass4StartLine = 1;

const TInt KPass1YPosIncrement = 8;

const TInt KPass2YPosIncrement = 8;

const TInt KPass3YPosIncrement = 4;

const TInt KPass4YPosIncrement = 2;

const TInt KPass1LineRepeat = 7;

const TInt KPass2LineRepeat = 3;

const TInt KPass3LineRepeat = 1;

const TInt KPass4LineRepeat = 0;

const TUint KLZWLimit = 20000;

const TInt KSetCommentsLimit = 64;

const TUint16 KTranspColIdxNotPresent = 0xFFFF;

// CGifReadCodec

CGifReadCodec::CGifReadCodec(TRgb* aGlobalPalette,TInt aBackgroundColorIndex, TSize aScreenSize,TBool aFastDecode):

	iBackgroundColorIndex(aBackgroundColorIndex),

	iScreenSize(aScreenSize),

	iGlobalPalette(aGlobalPalette),

	iFastDecode(aFastDecode)

	{

	}

CGifReadCodec::~CGifReadCodec()

	{

	iComment.ResetAndDestroy();

    delete [] iPrefixIndex;

	delete [] iSuffixCode;

	delete [] iOutputString;

	delete [] i64KPalette;

	delete [] iPixelBuffer;

	delete [] iMaskBuffer;

	}

CGifReadCodec* CGifReadCodec::NewL(TRgb* aGlobalPalette,TInt aBackgroundColorIndex, TSize aScreenSize,TBool aFastDecode)

	{

	CGifReadCodec* self = new(ELeave) CGifReadCodec(aGlobalPalette, aBackgroundColorIndex, aScreenSize, aFastDecode);

	CleanupStack::PushL(self);

    self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

	}

void CGifReadCodec::ConstructL()

    {

    CImageMaskProcessorReadCodec::ConstructL();

	iPrefixIndex    = new (ELeave) TInt16[KGifConversionTableSize +1];

	iSuffixCode     = new (ELeave) TUint8 [KGifConversionTableSize+1];

	iOutputString   = new (ELeave) TUint8 [KGifConversionTableSize];

	iPPos = &Pos();

	iPixelBuffer = NULL;

	iMaskBuffer = NULL;

    }

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

	{

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

	iFrameInfo = &aFrameSettings;

	iFrameData = &aFrameImageData;

	iFrameImageDesc = NULL;

	iFrameImageControl = NULL;

	iReadingOtherExtensionBlock=EFalse;

	iReadingCommentExtensionBlock = EFalse;

	iComment.ResetAndDestroy();

	iCommentIndex = 0;

	iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrameHeader);

	}

TFrameState CGifReadCodec::ProcessFrameHeaderL(TBufPtr8& aData)

	{	

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

	iDataPtr = iStartDataPtr;

	iDataPtrLimit = iStartDataPtr + aData.Length();

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

		{

		do	{

			//we need the block length (iDataPtr[0]+1) + the first byte of the next block

			//(used in the KGifTerminatorId evaluation below)

			if((iDataPtr + iDataPtr[0] + 2)<iDataPtrLimit)

				{// If there is enough data in the buffer to continue processing header info

				iFrameLZWInfo->iCompressedBytes += iDataPtr[0] + 1;

				// Shift the local buffer data pointer to point to the beginning of the next block

				iDataPtr += iDataPtr[0] + 1;

			}

			else

				{ // Else if there is not enough data in the buffer shift the 'aData' pointer

				// to point to the degining of the unused data and return to the calling method

				// so that the buffer can be refilled.

				aData.Shift((iDataPtr - iStartDataPtr));

				return EFrameIncomplete;

				}

			} while(iDataPtr[0]!=KGifFrameTerminatorId); //Continue until end of frame is reached

		if(iDataPtr[1] == KGifTerminatorId)

			{ // End of Image File

			DoSaveCommentsL();

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

			return EFrameComplete;

			}

		else if ((iDataPtr[1] == KGifImageDescriptorId) || (iDataPtr[1] == KGifExtensionId))

			{ // End of Frame

			DoSaveCommentsL();

			aData.Shift((iDataPtr - iStartDataPtr)+1); 

			iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingComplete);

			return EFrameIncomplete;

			}

		else

			{ // Unexpected end of data

			return EUnexpectedEndOfData;

			}

		}

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

		{

		TRAPD(err,DoProcessInfoL(iDataPtr,iDataPtrLimit));

		if (err == KErrCompletion)

			{

			DoSaveCommentsL();

			return EFrameComplete; // KGifTerminatorId found - no more images

			}

		if (err == KErrUnderflow)

			{

			TInt dataUsed = iDataPtr - iStartDataPtr;

			aData.Shift(dataUsed);

			TInt frameDataOffset = iFrameInfo->FrameDataOffset();

			iFrameInfo->SetFrameDataOffset(frameDataOffset + dataUsed);

			return EFrameIncomplete;

			}

		if (err!=KErrNone)

			{

			User::LeaveIfError(err); // A real error occured

			}

		if (iFrameImageDesc == NULL)

			{

			User::Leave(KErrCorrupt);

			}

		TInt frameDataOffset = iFrameInfo->FrameDataOffset();

		iFrameInfo->SetFrameDataOffset(frameDataOffset + (iDataPtr - iStartDataPtr));

		aData.Shift(iDataPtr - iStartDataPtr);

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

		iFrameInfo->iDelay = (iFrameImageControl) ? iFrameImageControl->iDelayTimeInCentiseconds * KGifCentiSecondsToMicroSeconds : 0;

		iFrameInfo->iFlags = TFrameInfo::EColor | TFrameInfo::ECanDither | TFrameInfo::EUsesFrameSizeInPixels;

		if (iFrameImageControl)

			{

			if (iFrameImageControl->iTransparentColorIndex != KErrNotFound)

				{

				iFrameInfo->iFlags |= TFrameInfo::ETransparencyPossible;

				if(iFrameImageDesc->iInterlaced)

					iFrameInfo->iFlags |= TFrameInfo::EPartialDecodeInvalid;

				}

			switch (iFrameImageControl->iDisposalMethod)

				{

			case TGifImageControl::ELeaveInPlace:

				iFrameInfo->iFlags |= TFrameInfo::ELeaveInPlace;

				break;

			case TGifImageControl::ERestoreToBackground:

				iFrameInfo->iFlags |= TFrameInfo::ERestoreToBackground;

				break;

			case TGifImageControl::ERestoreToPrevious:

				iFrameInfo->iFlags |= TFrameInfo::ERestoreToPrevious;

				break;

			case ENone:

			default:

				break;

				};

			}

		iFrameInfo->SetCurrentFrameState(TFrameInfo::EFrameInfoProcessingFrame);

		}

	return EFrameIncomplete;

	}

TFrameState CGifReadCodec::ProcessFrameL(TBufPtr8& aSrc)

	{

	if ((iFrameSize.iWidth == 0) || (iFrameSize.iHeight == 0))

		return EFrameComplete;

	iPixRead = 0;

	while (aSrc.Length() > 2 && !iComplete)

		{

		iDataPtr = aSrc.Ptr();

		const TInt dataSize = iDataPtr[0];

		iDataPtr++;

		if (dataSize == 0 || dataSize >= aSrc.Length())

		    {

		    break;

		    }

		iDataPtrLimit = iDataPtr + dataSize;

		DoProcessDataL();

		aSrc.Shift(dataSize + 1);

		}

	TPoint& pos = Pos();

	pos = *iPPos;

	FlushPixBuffer(iLatestPixSize);

	if (iFastAccessMode) 

		{

		const TInt frameWidth = iFrameSize.iWidth;

		TInt rowPixels = Min(frameWidth - pos.iX, iPixRead);

		pos.iX += rowPixels;

		iPixRead -= rowPixels;

		if (pos.iX == frameWidth)

			{

			TInt rowCount = iPixRead/frameWidth+1;

			pos.iY += rowCount;

			iPixRead -= (rowCount-1) * frameWidth;

			pos.iX = iPixRead;

			}

		iPixRead = 0;

		}

	if (pos.iY >= (iFrameSize.iHeight + iFrameOffset.iY) || iComplete)

		{

		ImageProcessor()->FlushPixels();

		CImageProcessor*const maskProc = MaskProcessor();

		if (maskProc)

			maskProc->FlushPixels();

		pos = iFrameOffset;

		//in case of iFast64kMode == true, palette is of type T64KPixel

		if(iGifImageControl && iGifImageControl->iTransparentColorIndex != KErrNotFound && !iFast64kMode)

			{

			// reset the transparency index

			if (iTranspColIdx != KTranspColIdxNotPresent)

				{

				const_cast<TRgb*>(&iPalette[iTranspColIdx])->SetAlpha(0xFF);

				}

			}

		return EFrameComplete;

		}

	return EFrameIncomplete;

	}

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

	{

  	iFrameInfo = &aFrameInfo;

  	iFrameData = &aFrameImageData;

	//Make the first frame's size equal to the image size

	if(CurrentFrame()==0)

		{

		iFrameSize = iFirstFrameSize;

		iFrameOffset = iFirstFrameCoords.iTl;

		}

	else

		{

		iFrameSize = iFrameInfo->iOverallSizeInPixels;

		iFrameOffset = TPoint(0,0);

		}

	iFrameCoords = iFrameInfo->iFrameCoordsInPixels;

	// If the width or height is zero return. A similar test in ProcessFrameL() will complete the image

	if ((iFrameSize.iWidth == 0) || (iFrameSize.iHeight == 0))

		{

		return;

		}

	if(iPixelBuffer == NULL || CurrentFrame() == 0)

		{

		iPixBufferSize = iFrameSize.iWidth * 8;//allocate buffer for first 8 lines

		if (iPixBufferSize > KPixelBufMaxSize) 

			{

			iPixBufferSize = KPixelBufMaxSize;

			}

		if (aDestinationMask != NULL)

			{

			iPixBufferSize /= 2;//reserve space for mask

			}

		delete[] iPixelBuffer;

		iPixelBuffer = new (ELeave) TUint32 [iPixBufferSize];

		}

	// Extract the image descriptor and control blocks.

	iGifImageDesc = NULL;

	iGifLZWInfo = NULL;

	iGifImageControl = NULL;

	iGifColorTable = NULL;

	TInt frameDataCount = iFrameData->FrameDataCount();

	for (TInt frameDataIndex = 0 ; frameDataIndex<frameDataCount ; frameDataIndex++)

		{

		TFrameDataBlock* frameData = iFrameData->GetFrameData(frameDataIndex);

		if (frameData->DataType() == KGIFImageDescriptorUid)

			{

			iGifImageDesc = STATIC_CAST(TGifImageDescriptor*, frameData);

			}

		else if(frameData->DataType() == KGIFColorTableUid)

			{

			iGifColorTable = STATIC_CAST(TGifColorTable*, frameData);

			}

		else if(frameData->DataType() == KGIFLZWInfoUid)

			{

			iGifLZWInfo = STATIC_CAST(TGifLZWInfo*, frameData);

			}

		else if(frameData->DataType() == KGIFImageControlUid)

			{

			iGifImageControl = STATIC_CAST(TGifImageControl*, frameData);

			}

		}

	iTranspColIdx = (iGifImageControl) ? iGifImageControl->iTransparentColorIndex : KTranspColIdxNotPresent;

	// Set decode info

	iPass = 1;

	iYPosIncrement = KPass1YPosIncrement;

	iBitBuffer = 0;

	iBitBuffSize = 0;

	iFirstChar = 0;

	iPreviousCode = -1;

	iComplete = EFalse;

	ASSERT(iGifImageDesc);

	ASSERT(iGifLZWInfo);

	// Set palette to use

	if(iGifImageDesc && iGifImageDesc->iLocalColorMap)

		{

		//Use of a frame palette was requested but was not found

		if(iGifColorTable == NULL)

			{

			User::Leave(KErrCorrupt);

			}

		iPalette = iGifColorTable->iPalette;

		}

	else

		{

		iPalette = iGlobalPalette;

		}

	// Set table.Check for iClearCode value between 0 and 4096.

	iClearCode = (1 << (iGifLZWInfo->iInitialCodeLength - 1));

	if((iClearCode < 0) || (iClearCode > KGifConversionTableSize))

		{

		User::Leave(KErrCorrupt);

		}

	iEoiCode = iClearCode + 1;

	for (TInt singleByteCodes = 0; singleByteCodes < iClearCode; singleByteCodes++)

		{

		iSuffixCode[singleByteCodes] = STATIC_CAST(TUint8,singleByteCodes);

		}

	TInt prefixLength = (KGifConversionTableSize + 1) * sizeof(TInt16);

	Mem::Fill(iPrefixIndex, prefixLength, TChar(static_cast<TUint>(-1)));

	iNextFree = ResetTableL();

	iReductionFactor = 0;

	CImageProcessor* imageProc = NULL;

	const TSize destinationSize(aDestination.SizeInPixels());

	if(iUseFrameSizeInPixels)

		{

		iReductionFactor = ReductionFactor(iFrameInfo->iFrameSizeInPixels,destinationSize);

		}

	else

		{

		iReductionFactor = ReductionFactor(iFrameInfo->iOverallSizeInPixels,destinationSize);

		}

    const TDisplayMode destMode = aDestination.DisplayMode();

    iFast64kMode = (iFastDecode &&

                    destMode == EColor64K && 

                    iReductionFactor == 0 && 

                    !iGifImageDesc->iInterlaced

                    );

    if (iFast64kMode && i64KPalette==NULL)

        {

        i64KPalette = new (ELeave) T64KPixel[KGifColorTableMaxEntries];

        Mem::FillZ(i64KPalette, KGifColorTableMaxEntries*sizeof(T64KPixel) );

        }

	if (!iGifImageDesc->iInterlaced && iReductionFactor==0 &&

	        (iFast64kMode || destMode == EColor16M || destMode == EColor16MU || destMode == EColor16MA) )

	    {

	    if (destMode == EColor16M) 

	    	{

	    	imageProc   = CRawImageUtilProcessor::NewL();

	    	}

		else

			{

    		imageProc   = CRawImageProcessor::NewL();

			}

	    }

    if (iFast64kMode)

        {

		// calculate fast 64K conversion palette		

        TInt idx = 0;

        do

            {

            i64KPalette[idx] = iPalette[idx]._Color64K();

            } 

            while (++idx < KGifColorTableMaxEntries);

        }

    if (imageProc == NULL)

        {

     	imageProc = ImageProcessorUtility::NewImageProcessorL(aDestination, iReductionFactor, iFast64kMode? EColor64K:ERgb, aDisableErrorDiffusion);    

        }

	SetImageProcessor(imageProc);

	iImgProc = imageProc;

	iPositionOffset = TPoint(iFrameCoords.iTl.iX >> iReductionFactor,iFrameCoords.iTl.iY >> iReductionFactor);

	TRect imageRegion(iPositionOffset + iFrameOffset,iPositionOffset + iFrameOffset + iFrameSize);

	imageProc->PrepareL(aDestination,imageRegion);

	imageProc->SetPos(iPositionOffset + iFrameOffset);

	SetPos(iFrameOffset);

	TInt lineLength	= (TDisplayModeUtils::NumDisplayModeBitsPerPixel( aDestination.DisplayMode() ) * aDestination.SizeInPixels().iWidth) >> 3;

	iFastAccessMode = (iReductionFactor == 0 && 

						!iGifImageDesc->iInterlaced && 

						imageRegion.Size() == aDestination.SizeInPixels() && 

						lineLength == aDestination.ScanLineLength(aDestination.SizeInPixels().iWidth, aDestination.DisplayMode())

						); // for direct access to bitmap buffer line length must be aligned to 4 bytes boundary

	if (iGifImageDesc->iInterlaced)

		{

		imageProc->SetYPosIncrement(iYPosIncrement);

		if(!iGifImageControl || (iGifImageControl->iTransparentColorIndex==KErrNotFound))

			{

			imageProc->SetLineRepeat(KPass1LineRepeat);

			}

		}

	CImageProcessor* maskProc = NULL;

	SetMaskProcessor(NULL);

	iMaskProc = NULL;

	if(aDestinationMask != NULL)

		{

		ASSERT(aDestinationMask->SizeInPixels() == aDestination.SizeInPixels());

			// this should be trapped at CImageDecoder::Convert()

		if (iGifImageControl && (iGifImageControl->iTransparentColorIndex != KErrNotFound) && aDestinationMask->Handle())

			{

			ASSERT(MaskProcessor()==NULL);

			if (iMaskBuffer == NULL || CurrentFrame() == 0)

			    {

			    delete [] iMaskBuffer; 

				iMaskBuffer     = new (ELeave) TUint32 [iPixBufferSize];

			    }

			iOpaqueMask	= 0xFF;// default for 256 mask

			//Create a mask processor  and disable error diffusion

			if (iGifImageDesc->iInterlaced || iReductionFactor > 0)

				{

				maskProc = ImageProcessorUtility::NewImageProcessorL(*aDestinationMask, iReductionFactor, EGray2, ETrue);	

				}

			else

				{

				// use optimized processor for non interlaced mask

				maskProc = CRawImageUtilProcessor::NewL();

				if(aDestinationMask->DisplayMode() == EGray2)

					{

					iOpaqueMask = 1;

					}

				}

			SetMaskProcessor(maskProc);

			iMaskProc = maskProc;

			maskProc->PrepareL(*aDestinationMask,imageRegion);

			if (iGifImageDesc->iInterlaced)

				{

				maskProc->SetYPosIncrement(iYPosIncrement);

				}

			// fill mask with black, so by default unknown parts don't draw

			ClearBitmapL(*aDestinationMask,KRgbBlack);

			maskProc->SetPos(iPositionOffset + iFrameOffset);

			lineLength	= (TDisplayModeUtils::NumDisplayModeBitsPerPixel( aDestinationMask->DisplayMode() ) * aDestinationMask->SizeInPixels().iWidth) >> 3;

			iFastAccessMode = iFastAccessMode && lineLength == aDestinationMask->ScanLineLength(aDestinationMask->SizeInPixels().iWidth, aDestinationMask->DisplayMode()); // for direct access 

			// to bitmap buffer line length must be aligned to 4 bytes boundary

			}

		}

    else

		{