// Copyright (c) 2004-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 "ExifThumbnailGenerator.h"
#include <imageconversion.h>
#include <bitmaptransforms.h>
#include "JpegTypes.h"
#include "jpegwritecodec.h"

#include "ExifGeneralConsts.h"

#include "exiftransformdataaccessor.h"

CScaledJpegGenerator* CScaledJpegGenerator ::NewL(TRequestStatus* aNotifier, const MExifSource* aSource, 
	TBool aMaintainAspectRatio, CImageDecoder::TOptions aDecoderOptions)
	{
	CScaledJpegGenerator* self= new (ELeave) CScaledJpegGenerator(aNotifier, aMaintainAspectRatio, aDecoderOptions);
	CleanupStack::PushL(self);
	self->ConstructL(aSource);
	CleanupStack::Pop(self);
	
	return self;	
	}
	
HBufC8* CScaledJpegGenerator::GetJpegDataL()
	{
	if(iState!=EFinished)
		{
		User::Leave(KErrInUse);
		}
	if(iJPegImage.Count()==0)
		{
		User::Leave(KErrNotFound);
		}

	TInt size=0;
	TInt i;
	for(i=0; i<iJPegImage.Count(); i++)
		{
		size += iJPegImage[i]->Length();
		}
	HBufC8* thumbnailData=HBufC8::NewL(size);
	TPtr8 bufPtr(thumbnailData->Des());
	
	for(i=0; i<iJPegImage.Count(); i++)
		{
		bufPtr.Append(*(iJPegImage[i]));
		}
	
	return thumbnailData;
	}

HBufC8* CScaledJpegGenerator::JpegDataBufferL(const TUint aIndex)
	{
	if (iState != EFinished)
		{
		User::Leave(KErrInUse);
		}
	if (iJPegImage.Count() == 0)
		{
		User::Leave(KErrNotFound);
		}

	if (aIndex < iJPegImage.Count())
		{
		return iJPegImage[aIndex]->AllocL();
		}
	else
		{
		return NULL;
		}
	}
	
CScaledJpegGenerator::CScaledJpegGenerator(TRequestStatus* aNotifier, TBool aMaintainAspectRatio, 
	CImageDecoder::TOptions aDecoderOptions)
	: CActive(EPriorityStandard), iNotifier(aNotifier), iState(EFinished), 
	iMaintainAspectRatio(aMaintainAspectRatio)
	{	
	iDecoderOptions = aDecoderOptions;
	}

CScaledJpegGenerator::~CScaledJpegGenerator()
	{
	Cancel();
	CleanData();
	iJPegImage.Close();
	}
	
void CScaledJpegGenerator::ConstructL(const MExifSource* aSource)
	{
	ASSERT(aSource != NULL);
	iSource = aSource;
	CActiveScheduler::Add(this);
	}
	


void CScaledJpegGenerator::StartL(TSize aSize, TImageToGenerate aImageType)
	{
	if(iState!=EFinished)
		{
		User::Leave(KErrInUse);
		}
	
	
	CleanResultData();
	CleanTempData();
	iSize=aSize;
	iImageType=aImageType;
	
	if(!iImageDecoder)
		{
		iImageDecoder = iSource->CreateImageDecoderL(iDecoderOptions);
		TFrameInfo frameInfo= iImageDecoder->FrameInfo();

		if(iBitmap)
			{
			delete iBitmap;
			iBitmap = NULL;
			}
		iBitmap= new (ELeave) CFbsBitmap();
		
		User::LeaveIfError(iBitmap->Create(frameInfo.iFrameCoordsInPixels.Size(), frameInfo.iFrameDisplayMode));
		iState=EDecode;
		iImageDecoder->Convert(&iStatus, *iBitmap);
		SetActive();
		}
	else
		{	// the initialisation has already been done, there is no need to do it again
		DoScaleBitmapL();
		SetActive();
		}
	*iNotifier=KRequestPending;
	}

void CScaledJpegGenerator::RunL()
	{
	if(iStatus.Int()==KErrNone)
		{
		switch(iState)
			{
			case EDecode:
				// the decode is finished, we now scale the image
				DoScaleBitmapL();
				SetActive();
				break;
				
			case EScale:
				 // the scaling is over. We now Convert the image
				DoConvertL();
				SetActive();
				break;
			case EConvert:
				{
				switch(iFrameState)
					{
					case EFrameIncomplete:
						DoConvertL();
						SetActive();
						break;
					case EFrameComplete:
						GenerationCompleteL();
						break;
					default:
						iStatus=KErrCorrupt;
						RunError(KErrCorrupt);
					}
				}
				break;
			case EFinished:
				break;
			default:
				break;
			}
		// we have the bitmap, now scale it
		}
	else
		{
		RunError(iStatus.Int());
		}
	}
	
void CScaledJpegGenerator::DoCancel()
	{
	if (iImageDecoder)
		{
		iImageDecoder->Cancel();
		}
	if (iBitmapScaler)
		{
		iBitmapScaler->Cancel();
		}
	CleanData();
	User::RequestComplete(iNotifier, KErrCancel);
	iState=EFinished;
	}
	
void CScaledJpegGenerator::DoScaleBitmapL()
	{
	if(iBitmapScaler)
		{
		delete iBitmapScaler;
		iBitmapScaler = NULL;
		}
	iBitmapScaler=CBitmapScaler::NewL();

	iBitmapScaler->UseLowMemoryAlgorithm(ETrue);
	iBitmapScaler->Scale(&iStatus, *iBitmap, iSize, iMaintainAspectRatio);
	iState=EScale;
	}


 // returns ETrue if it is the last chunk of data to be received
void CScaledJpegGenerator::DoConvertL()
	{
	if(iState!=EConvert)
		{
		delete iBitmapScaler;
		iBitmapScaler=NULL;
		CreateJpegCodecL();
		if(iJpegChunck)
			{
			delete iJpegChunck;
			iJpegChunck = NULL;
			}
		iJpegChunck=HBufC8::NewMaxL(4096);
		iJpegChunckPtr.Set(*iJpegChunck);

		if(iImageType==EThumbnail)
			{
			// write SOI
			iJpegChunckPtr[0] = (TUint8)((KJpgSOISignature & 0xff00) >> 8);
			iJpegChunckPtr[1] = (TUint8)(KJpgSOISignature & 0xff);
			iJpegChunckPtr.Shift(2);
			}
		
		iJpegCodec->InitFrameL(iJpegChunckPtr, *iBitmap);
		
		if(iImageType==EThumbnail)
			{
			// Adjust iJpegChunckPtr to account for SOI added above 
			TInt len=iJpegChunckPtr.Length() + 2;
			iJpegChunckPtr.Set(*iJpegChunck);
			iJpegChunckPtr.SetLength(len);		
			}
			
		HBufC8* buf = iJpegChunckPtr.AllocLC();
		iJPegImage.AppendL(buf);
		CleanupStack::Pop(buf);
		iJpegChunckPtr.Set(*iJpegChunck);
		iFrameState=EFrameIncomplete;
		}
	else
		{
		iFrameState= iJpegCodec->ProcessFrameL(iJpegChunckPtr);
		HBufC8* buf = iJpegChunckPtr.AllocLC();
		iJPegImage.AppendL(buf);
		CleanupStack::Pop(buf);
		}	
	

	iStatus=KRequestPending;
	TRequestStatus* status=&iStatus;
	User::RequestComplete(status, KErrNone);
	iState=EConvert;
	}


void CScaledJpegGenerator::CreateJpegCodecL()
	{
	const CFrameImageData* frameImageData= &iImageDecoder->FrameData();

	//PDEF115929
	//This should not be the case - corrupt file
	if (frameImageData == NULL)
		{
		User::Leave(KErrCorrupt);
		}

	TJpgFrameInfo frameInfo;
	TInt qualityFactor;

	qualityFactor = 0;

 	TInt count = frameImageData->ImageDataCount();

	//PDEF115929
	//This should not be the case - corrupt file
	if (count == 0)
		{
		User::Leave(KErrCorrupt);
		}

	TBool jpgImageDataProcessed = EFalse;
	for (TInt index = 0 ; index<count ; index++)
		{	
		const TImageDataBlock& encoderData = *frameImageData->GetImageData(index);
		if (encoderData.DataType() == KJPGImageDataUid)
			{
			// Leave if we have already processed one of these.
			if (jpgImageDataProcessed)
				User::Leave(KErrCorrupt);

			const TJpegImageData& jpegImageData = STATIC_CAST(const TJpegImageData&, encoderData);
			qualityFactor = jpegImageData.iQualityFactor;

			TJpegImageData::TColorSampling sampleScheme = jpegImageData.iSampleScheme;
			frameInfo.iComponent[0].iQTable = 0;
			if (sampleScheme == TJpegImageData::EMonochrome)
				{
				frameInfo.iNumberOfComponents = 1;
				frameInfo.iComponent[0].iHorzSampleFactor = 1;
				frameInfo.iComponent[0].iVertSampleFactor = 1;
				}
			else
				{
				frameInfo.iNumberOfComponents = 3;
				switch (sampleScheme)
					{
				case TJpegImageData::EColor420:
					frameInfo.iComponent[0].iHorzSampleFactor = 2;
					frameInfo.iComponent[0].iVertSampleFactor = 2;
					frameInfo.iComponent[1].iVertSampleFactor = 1;
					frameInfo.iComponent[2].iVertSampleFactor = 1;
					break;
				case TJpegImageData::EColor422:
					frameInfo.iComponent[0].iHorzSampleFactor = 2;
					frameInfo.iComponent[0].iVertSampleFactor = 1;
					frameInfo.iComponent[1].iVertSampleFactor = 1;
					frameInfo.iComponent[2].iVertSampleFactor = 1;
					break;
				case TJpegImageData::EColor444:
					frameInfo.iComponent[0].iHorzSampleFactor = 1;
					frameInfo.iComponent[0].iVertSampleFactor = 1;
					frameInfo.iComponent[1].iVertSampleFactor = 1;
					frameInfo.iComponent[2].iVertSampleFactor = 1;
					break;
				default:
					User::Leave(KErrNotSupported);
					}

				frameInfo.iComponent[1].iHorzSampleFactor = 1;
				frameInfo.iComponent[1].iQTable = 1;
				frameInfo.iComponent[2].iHorzSampleFactor = 1;
				frameInfo.iComponent[2].iQTable = 1;
				}
			
			frameInfo.iMaxHorzSampleFactor = frameInfo.iComponent[0].iHorzSampleFactor;
			frameInfo.iMaxVertSampleFactor = frameInfo.iComponent[0].iVertSampleFactor;

			jpgImageDataProcessed = ETrue;
			}
		else if (encoderData.DataType() == KJPGQTableUid)
			{
			const TJpegQTable& jpegQTable = STATIC_CAST(const TJpegQTable&, encoderData);
			TInt tableIndex = jpegQTable.iTableIndex;
			if ((tableIndex != TJpegQTable::ELumaTable) && (tableIndex != TJpegQTable::EChromaTable))
				{
				// This can happen if client has given us a second chroma QTable
				// replacement.  We do not support this at present, so we ignore
				// the extra Q table and encode using the same QTable for both
				// chroma components.
				continue;
				}

			TUint8 values[KJpgQTableEntries];
			TUint8* valuePtr = values;
			const TUint8* zigZagPtr = KZigZagSequence.iZigZag;
			const TUint8* valuePtrLimit = valuePtr + KJpgQTableEntries;

			while (valuePtr < valuePtrLimit)
				*valuePtr++ = jpegQTable.iEntries[*zigZagPtr++];

			if (tableIndex == TJpegQTable::ELumaTable)
				{
				delete iLumaTable;
				iLumaTable=NULL;
				iLumaTable = new(ELeave) TQTable;

				iLumaTable->Set(values, EFalse);
				}
			else // tableIndex must be TJpegQTable::EChromaTable
				{
				delete iChromaTable;
				iChromaTable=NULL;
				iChromaTable = new(ELeave) TQTable;

				iChromaTable->Set(values, EFalse);
				}
			}
		else if ((encoderData.DataType() == KJPGCommentUid))
			{
			if (iImageType == EMainImage) 
				{
				const TJpegComment& jpegComment = STATIC_CAST(const TJpegComment&, encoderData);
				if (!jpegComment.iComment)
					User::Leave(KErrNotFound);

				if ((jpegComment.iComment->Length() == 0) || (jpegComment.iComment->Length() > 65534))
					User::Leave(KErrNotSupported);
	            
	        	HBufC8* thisComment = jpegComment.iComment->AllocL();
		    	TInt ret = iComment.Append(thisComment);
			    if (ret != KErrNone)
			    	{
			    	delete thisComment;
			    	User::Leave(ret);
				    }
				
				}
			}
		else
			User::Leave(KErrCorrupt);
		}

	iJpegCodec= CJpgWriteCodec::NewL(frameInfo,qualityFactor,iLumaTable,iChromaTable,iComment,NULL);
	}


TInt CScaledJpegGenerator::RunError(TInt aError)
	{
	CleanData();
	User::RequestComplete(iNotifier, aError);
	iState=EFinished;
	
	return KErrNone;
	}
	
void CScaledJpegGenerator::GenerationCompleteL()
	{
	// write EOI
	TBuf8<2> buffer2Bytes;
	buffer2Bytes.SetLength(2);
	TUint8* headerPtr2 = &buffer2Bytes[0];
	headerPtr2[0] = (TUint8)((KJpgEOISignature & 0xff00) >> 8);
	headerPtr2[1] = (TUint8)(KJpgEOISignature & 0xff);
	HBufC8* buf = buffer2Bytes.AllocLC();
	iJPegImage.AppendL(buf);
	CleanupStack::Pop(buf);
	iState=EFinished;
	CleanTempData();
	User::RequestComplete(iNotifier, KErrNone);
	}

void CScaledJpegGenerator::CleanTempData()
	{
	delete iJpegCodec;
	iJpegCodec=NULL;
	delete iBitmapScaler;
	iBitmapScaler=NULL;

	delete iJpegChunck;
	iJpegChunck=NULL;

	iComment.ResetAndDestroy();
	delete iLumaTable;
	iLumaTable=NULL;
	delete iChromaTable;
	iChromaTable=NULL;
	}

void CScaledJpegGenerator::CleanResultData()
	{
	iJPegImage.ResetAndDestroy();
	}
	
void CScaledJpegGenerator::CleanData()
	{
	CleanTempData();
	CleanResultData();
	
	delete iImageDecoder;
	iImageDecoder=NULL;
	delete iBitmap;
	iBitmap=NULL;
	}

void CScaledJpegGenerator::GetScaledImageSize(TSize &aSize)
	{
	if (iBitmap)
		{
		aSize = iBitmap->SizeInPixels();
		}
	else
		{
		aSize = iSize;
		}
	}