// Copyright (c) 1997-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:
// Licensed under US Patent No 4,558,302 and foreign counterparts
// 
//

#include <imageconversion.h>
#include "ImageClientMain.h"
#include "ImageUtils.h"
#include <barsc.h>
#include <barsread.h>
#include <bautils.h>
#include <101F45B1_extra.rsg>
#include "GIFConvert.h"
#include "icl/ICL_UIDS.hrh"
#include <gifscaler.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <icl/icl_uids_const.hrh>
#include <icl/icl_uids_def.hrh>
#include <icl/imagecodecdef.h>
#endif

_LIT(KGIFPanicCategory, "GIFConvertPlugin");

// Global panic function
GLDEF_C void Panic(TIclPanic aError)
	{
	User::Panic(KGIFPanicCategory, aError);
	}

CGifDecoder* CGifDecoder::NewL()
	{
	return new(ELeave) CGifDecoder;
	}

CGifDecoder::CGifDecoder()
	{
	}

CGifDecoder::~CGifDecoder()
	{
	CImageDecoderPlugin::Cleanup();
	}

void CGifDecoder::ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aImageSubType) const
	{
	__ASSERT_ALWAYS((aFrameNumber >= 0) && (aFrameNumber < NumberOfFrames()), Panic(EFrameNumberOutOfRange));
	aImageType = KImageTypeGIFUid;
	aImageSubType = KNullUid;
	}

TInt CGifDecoder::NumberOfImageComments() const
	{
	__ASSERT_ALWAYS(IsImageHeaderProcessingComplete(), Panic(EHeaderProcessingNotComplete));
	const CFrameImageData& frameImageData = FrameData(0);
	TInt imageCommentCount = 0;
	const TInt imageDataCount = frameImageData.ImageDataCount();
	for (TInt count = 0; count < imageDataCount; count++)
		{
		const TImageDataBlock* imageData = frameImageData.GetImageData(count);
		if (imageData->DataType() == KGIFCommentUid)
			imageCommentCount++;
		}

	return imageCommentCount;
	}

HBufC* CGifDecoder::ImageCommentL(TInt aCommentNumber) const
	{
	__ASSERT_ALWAYS(IsImageHeaderProcessingComplete(), Panic(EHeaderProcessingNotComplete));
	__ASSERT_ALWAYS((aCommentNumber >= 0) && (aCommentNumber < NumberOfImageComments()), Panic(ECommentNumberOutOfRange));

	const CFrameImageData& frameImageData = FrameData(0);
	TInt commentCount = 0;
	TInt imageDataCount = frameImageData.ImageDataCount();
	const TImageDataBlock* imageData = NULL;
	for (TInt count = 0; count < imageDataCount; count++)
		{
		imageData = frameImageData.GetImageData(count);
		if (imageData->DataType() == KGIFCommentUid)
			{
			if (commentCount == aCommentNumber)
				{
				break;
				}
			commentCount++;
			}
		}

	const TGifComment* gifComment = STATIC_CAST(const TGifComment*,imageData);
	HBufC* comment = NULL;
	if (gifComment)
		{
		comment = HBufC::NewL(gifComment->iComment->Length());
		comment->Des().Copy(*(gifComment->iComment)); // Create a 16 bit copy of the 8 bit original	
		}
	
	return comment;
	}

void CGifDecoder::ScanDataL()
	{
	ReadFormatL();

	ASSERT(ImageReadCodec()==NULL);
	CGifReadCodec* imageReadCodec = CGifReadCodec::NewL(iGlobalPalette, iFileInfo.iBackgroundColorIndex, iFileInfo.iScreenSize,
	                                ( (DecoderOptions() & CImageDecoder::EPreferFastDecode) == CImageDecoder::EPreferFastDecode)
	            );

	SetImageReadCodec(imageReadCodec);
	
	if((DecoderOptions()&CImageDecoder::EOptionUseFrameSizeInPixels) == CImageDecoder::EOptionUseFrameSizeInPixels)
		{
		imageReadCodec->SetUseFrameSizeInPixels(ETrue);
		}

	ReadFrameHeadersL();
	}

void CGifDecoder::ReadFormatL()
	{
	TPtrC8 bufferDes;

	// Read the header (+ 1 extra byte, so that we can check the first block id is valid)
	ReadDataL(0, bufferDes, (KGifFileInformationSize + (KGifColorTableMaxEntries * KGifPaletteEntrySize) + 1));

	// Validate the header.
	if (bufferDes.Length() < KGifFileInformationSize)
		User::Leave(KErrUnderflow);

	iFileInfo.iSignature = bufferDes.Left(KGifSignatureLength);
	if (iFileInfo.iSignature != KGif87aFileSignature && 
		iFileInfo.iSignature != KGif89aFileSignature)
		User::Leave(KErrCorrupt);

	const TUint8* ptr = &bufferDes[KGifSignatureLength];
	iFileInfo.iScreenSize.iWidth = PtrReadUtil::ReadUint16(ptr);
	ptr+=2;

	iFileInfo.iScreenSize.iHeight = PtrReadUtil::ReadUint16(ptr);
	ptr+=2;

	TUint8 flags = *ptr++;
	iFileInfo.iBitsPerPixel = (flags & 0x07) + 1;
	iFileInfo.iColorResolutionBits = ((flags & 0x70) >> 4) + 1;
	iFileInfo.iGlobalColorMap = flags & 0x80;
	if (iFileInfo.iSignature == KGif89aFileSignature)
		iFileInfo.iSortedGlobalMap = flags & 0x08;

	if (iFileInfo.iGlobalColorMap)
		{
		iFileInfo.iBackgroundColorIndex = *ptr;
		iGlobalPaletteEntries = 1 << iFileInfo.iBitsPerPixel;
		}
	else
		{
		iFileInfo.iBackgroundColorIndex = KErrNotFound;
		iGlobalPaletteEntries = 0;
		}

	ptr++;
	TUint8 pixelAspectRatio = *ptr;
	if (iFileInfo.iSignature == KGif87aFileSignature)
		{
		iFileInfo.iPixelAspectRatio = pixelAspectRatio & 0x7f;
		iFileInfo.iSortedGlobalMap = pixelAspectRatio & 0x80;
		}
	else
		iFileInfo.iPixelAspectRatio = pixelAspectRatio;

	if (iFileInfo.iGlobalColorMap)
		{
		if (bufferDes.Length() < (KGifFileInformationSize + iGlobalPaletteEntries * KGifPaletteEntrySize))
			User::Leave(KErrUnderflow);

		const TUint8* ptr = &bufferDes[KGifFileInformationSize];
		TRgb* palettePtr = iGlobalPalette;
		TRgb* palettePtrLimit = iGlobalPalette + iGlobalPaletteEntries;

		while (palettePtr < palettePtrLimit)
			{
			*palettePtr++ = TRgb(ptr[0],ptr[1],ptr[2]);
			ptr += KGifPaletteEntrySize;
			}

		palettePtrLimit = iGlobalPalette + KGifColorTableMaxEntries;
		while (palettePtr < palettePtrLimit)
			*palettePtr++ = KRgbWhite;

		TGifBackgroundColor* gifBackgroundColor = new(ELeave) TGifBackgroundColor;
		gifBackgroundColor->iBackgroundColorIndex = iFileInfo.iBackgroundColorIndex;
		gifBackgroundColor->iBackgroundColor = iGlobalPalette[iFileInfo.iBackgroundColorIndex];
		CleanupStack::PushL(gifBackgroundColor);

		User::LeaveIfError(AppendImageData(gifBackgroundColor));
		CleanupStack::Pop(); // gifBackgroundColor
		}

	if (bufferDes.Length() < (KGifFileInformationSize + (iGlobalPaletteEntries * KGifPaletteEntrySize)) + 1)
		User::Leave(KErrUnderflow);
	
	// Check that first byte after the global color table is a valid block id
	TUint8 nextBlockId = bufferDes[KGifFileInformationSize + (iGlobalPaletteEntries * KGifPaletteEntrySize)];
	switch (nextBlockId)
		{
		case KGifExtensionId:
		case KGifImageDescriptorId:
		case KGifPlainTextExtensionId:
		case KGifGraphicControlExtensionId:
		case KGifCommentExtensionId:
		case KGifApplicationExtensionId:
			break;

		default:
			User::Leave(KErrCorrupt);
		}
	
	TInt startPosition = KGifFileInformationSize;
	if (iFileInfo.iGlobalColorMap)
		startPosition += iGlobalPaletteEntries * KGifPaletteEntrySize;
	SetStartPosition(startPosition);

	TFrameInfo imageInfo;
	imageInfo = ImageInfo();
	imageInfo.iOverallSizeInPixels = iFileInfo.iScreenSize;
	imageInfo.iBitsPerPixel = iFileInfo.iBitsPerPixel;
	imageInfo.iFrameSizeInTwips.SetSize(0,0);
	if (iFileInfo.iGlobalColorMap)
		{
		imageInfo.iBackgroundColor = iGlobalPalette[iFileInfo.iBackgroundColorIndex];
		if (iFileInfo.iColorResolutionBits<=4)
			imageInfo.iFrameDisplayMode = EColor4K;
		else
			imageInfo.iFrameDisplayMode = EColor16M;
		}
	else
		imageInfo.iFrameDisplayMode = EColor256;
	imageInfo.iDelay = KErrNotFound;

	SetImageInfo(imageInfo);
	SetDataLength(KMaxTInt); // Set default data length in case format header doesn't contain this information
	}

CFrameInfoStrings* CGifDecoder::FrameInfoStringsL(RFs& aFs, TInt aFrameNumber)
	{
	const TUid KGifCodecDllUid = {KGIFCodecDllUidValue};

	RResourceFile resourceFile;
	OpenExtraResourceFileLC(aFs,KGifCodecDllUid,resourceFile);

	HBufC8* resourceInfo = resourceFile.AllocReadLC(THEDECODERINFO);
	TResourceReader resourceReader;
	resourceReader.SetBuffer(resourceInfo);

	TBuf<KCodecResourceStringMax> info;
	TBuf<KCodecResourceStringMax> templte;

	const TFrameInfo& frameInfo = FrameInfo(aFrameNumber);
	CFrameInfoStrings* frameInfoStrings = CFrameInfoStrings::NewLC();

	info = resourceReader.ReadTPtrC();
	frameInfoStrings->SetDecoderL(info);

	CDesCArrayFlat* resourceArray = resourceReader.ReadDesCArrayL();
	CleanupStack::PushL(resourceArray);
	TUint formatIndex = (iFileInfo.iSignature == KGif87aFileSignature) ? 0 : 1;
	info = (*resourceArray)[formatIndex];
	CleanupStack::PopAndDestroy(resourceArray);
	frameInfoStrings->SetFormatL(info);

	TInt width = frameInfo.iOverallSizeInPixels.iWidth;
	TInt height = frameInfo.iOverallSizeInPixels.iHeight;
	TInt depth = frameInfo.iBitsPerPixel;

	templte = resourceReader.ReadTPtrC();
	info.Format(templte, width, height);
	frameInfoStrings->SetDimensionsL(info);

	templte = resourceReader.ReadTPtrC();
	info.Format(templte, depth);
	frameInfoStrings->SetDepthL(info);

	// leave details blank

	CleanupStack::Pop(frameInfoStrings); 
	CleanupStack::PopAndDestroy(2); // resourceInfo + resourceFile
	return frameInfoStrings;
	}

// Gif encoder.
CGifEncoder* CGifEncoder::NewL()
	{
	CGifEncoder* self = new(ELeave) CGifEncoder;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;

	}

CGifEncoder::CGifEncoder()
	{
	}

void CGifEncoder::ConstructL()
	{
	iPalette = CPalette::NewDefaultL(EColor256);
	}

CGifEncoder::~CGifEncoder()
	{
	if (iGifScaler)
		{
		iGifScaler->Cancel();
		delete iGifScaler;
		}
	delete iPalette;
	delete iDest;
	CImageEncoderPlugin::Cleanup();
	}

const CPalette* CGifEncoder::Palette() const
	{
	return iPalette;
	}

void CGifEncoder::WriteExifDataL(TRequestStatus*& aScaleCompletionStatus)
	{
	if ((EncoderOptions() & CImageEncoder::EOptionGenerateAdaptivePalette) == CImageEncoder::EOptionGenerateAdaptivePalette)
		{
		if (!iPalette)
			{
			iPalette = CPalette::NewL(KGifColorTableMaxEntries);	
			}
		iGifScaler->Scale(aScaleCompletionStatus, *iDest, *iPalette);
		}
	else
		{
		// the framework waits for aScaleCompletionStatus to complete
		SelfComplete(KErrNone);
		}
	}

void CGifEncoder::PrepareEncoderL(const CFrameImageData* aFrameImageData)
	{
	// Create the codec.
	StartPosition() = KGifFileInformationSize;
	StartPosition() += KGifColorTableMaxEntries * KGifPaletteEntrySize;
	ASSERT(ImageWriteCodec() == NULL);
	
	// ensure iPalette is NULL to start with since CGifWriteCodec::FillBufferL() behaviour depends on it
	delete iPalette;
	iPalette = NULL;

	// check to see if client has supplied a palette
	if (aFrameImageData)
		{
		TInt frameDataCount = aFrameImageData->FrameDataCount();
		TGifColorTable* gifColorTable = NULL;
		for (TInt frameDataIndex = 0; frameDataIndex < frameDataCount; frameDataIndex++)
			{
			TFrameDataBlock* frameData = const_cast<TFrameDataBlock*>(aFrameImageData->GetFrameData(frameDataIndex));
			if (frameData->DataType() == KGIFColorTableUid)
				{
				gifColorTable = static_cast<TGifColorTable*>(frameData);
				}
			}

		if (gifColorTable)
			{
			if (!iPalette)
				{
				iPalette = CPalette::NewL(KGifColorTableMaxEntries);	
				}
			for (TInt i = 0; i < KGifColorTableMaxEntries; i++)
				{
				iPalette->SetEntry(i, gifColorTable->iPalette[i]);
				}
			}
		}

	if ((EncoderOptions() & CImageEncoder::EOptionGenerateAdaptivePalette) == CImageEncoder::EOptionGenerateAdaptivePalette)
		{
		CFbsBitmap* sourceBitmap = const_cast<CFbsBitmap*>(&Source());
		delete iGifScaler;
		iGifScaler = NULL;
		iGifScaler = CGifScaler::NewL(*sourceBitmap);

		delete iDest;
		iDest = NULL;
		iDest = new (ELeave) CFbsBitmap;
		User::LeaveIfError(iDest->Create(sourceBitmap->SizeInPixels(), EColor256));
		}

	CGifWriteCodec* imageWriteCodec = CGifWriteCodec::NewL(*this);
	
	SetImageWriteCodec(imageWriteCodec);

	}

void CGifEncoder::UpdateHeaderL()
	{
	TInt headerSize = KGifFileInformationSize + (KGifColorTableMaxEntries * KGifPaletteEntrySize);

	HBufC8* gifHeaderPtr = HBufC8::NewMaxLC(headerSize);
	TUint8* headerPtr = &gifHeaderPtr->Des()[0];

	Mem::Copy(headerPtr,&KGif87aFileSignature()[0],KGifSignatureLength); headerPtr += KGifSignatureLength;

	TInt width = Source().SizeInPixels().iWidth;
	TInt height = Source().SizeInPixels().iHeight;
	PtrWriteUtil::WriteInt16(headerPtr, width);
	headerPtr+=2;
	PtrWriteUtil::WriteInt16(headerPtr, height);
	headerPtr+=2;
	TUint8 resolutionFlag = 0;
	resolutionFlag |= 8 - 1; // Bpp - 1
	resolutionFlag |= (8 - 1) << 4; // Color Resolution
	resolutionFlag |= 0x80; // Global Color Table Flag
	*headerPtr++ = resolutionFlag;
	*headerPtr++ = 255; // Background Color Index
	*headerPtr++ = 0; // Pixel Aspect Ratio

	for (TInt paletteIndex = 0; paletteIndex < KGifColorTableMaxEntries; paletteIndex++)
		{
		TRgb entry;
		if (iPalette)
			{
			entry = iPalette->GetEntry(paletteIndex);
			}
		else
			{
			entry = TRgb::Color256(paletteIndex);			
			}

		headerPtr[0] = (TUint8)entry.Red();
		headerPtr[1] = (TUint8)entry.Green();
		headerPtr[2] = (TUint8)entry.Blue();
		headerPtr += 3;
		}

	TPtr8 bufferDes(gifHeaderPtr->Des());
	WriteDataL(0,bufferDes);

	CleanupStack::PopAndDestroy(); // gifHeaderPtr
	}