// 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:
//

#ifndef __JPEGCONVERT_H__
#define __JPEGCONVERT_H__

#include "icl/ImagePlugin.h"
#include "icl/ImageCodecData.h"

#include "JPEGExifPlugin.h"
#include <iclexifimageframe.h>
#include "JpegTypes.h"
#include "imageframe.h"
#include "pluginextensionmanager.h"

#include <icl/imageconversionextension.h>
#include <icl/imageconversionextensionintf.h>


// Decoder.
class CJpgReadCodec;
class CExifDecoder;
class CStreamedDecodeExtension;

class CJpegDecoder : public CJPEGImageFrameDecoderPlugin
	{
public:
 	static CJpegDecoder* NewL();
	~CJpegDecoder();

	void ImageType(TInt aFrameNumber, TUid& aImageType, TUid& aCodecType) const;
	CFrameInfoStrings* FrameInfoStringsL(RFs& aFs, TInt aFrameNumber);

	TInt NumberOfFrameComments(TInt aFrameNumber) const;
	HBufC* FrameCommentL(TInt aFrameNumber, TInt aCommentNumber) const;

	// Extension operations
	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);

	TInt HandleStreamGetBufferSize(TUid aFormat, TSize& aBlockSizeInPixels, TInt aNumBlocks) const;
	void HandleStreamInitFrameL(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps::TNavigation aNavigation);
	void HandleStreamGetBlocks(CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead);
	void HandleStreamGetNextBlocks(CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks);

	// From CJPEGExifDecoderPlugin
	virtual MExifMetadata* ExifMetadata();
	virtual void SetClippingRectL(const TRect* aRect);
	virtual TInt GetDestinationSize(TSize& aSize, TInt aFrameNumber);
	
	TInt SamplingScheme(TJpegImageData::TColorSampling& aSamplingScheme) const;

protected:
	void ScanDataL();
	TInt FrameHeaderBlockSize(TInt aFrameNumber) const;
	TInt FrameBlockSize(TInt aFrameNumber) const;

	// From CImageDecoderPlugin
	void InitConvertL();
	void DoConvert();
	void HandleCustomSyncL(TInt aParam);
	void InitCustomAsyncL(TInt aParam);
	void NotifyComplete();

private:
	CJpegDecoder();

	// From CImageDecoderPlugin
	// Called by ScanDataL.
	// Opens file, scans header and validates format.
	void ReadFormatL();

	// New functions
	void LoadBlockL();
	void ProcessApp0L();
	void ProcessApp1L();
	void ProcessAppEL();
	void ProcessHuffmanTableL();
	void ProcessQTableL();
	void ProcessStartOfFrameL();
	void ProcessStartOfScanL();
	void ProcessRestartInterval();
	void ProcessCommentL();
	void FinishedProcessing();

	// Fill in image data structures, to be returned in calls to ImageData.
	void InitialiseImageDataL();

	// Handle async command for EOptionConvertFrame
	void HandleConvertFrameL();

	// Handle async command for EOptionContinueConvertFrame
	void HandleContinueConvertFrameL();

	// Check real size of comment block and adjust data read
	void CheckCommentBlockL();

protected:
	TUint16 iBlockSignature;
	TInt iBlockLength;
	TInt iImageOffset;
	const TUint8* iPtr;

	TJpgFrameInfo iJpgFrameInfo;
	TJpgScanInfo iScanInfo;
	TDecHuffmanTable iDCHuffmanTable[KJpgMaxNumberOfTables];
	TDecHuffmanTable iACHuffmanTable[KJpgMaxNumberOfTables];
	TQTable iQTable[KJpgMaxNumberOfTables];

	CExifDecoder* iExifDecoder;

	// Derived from the base class CJPEGExifDecoderPlugin.
	void NotifyImageTypeChangeL(TInt aImageType);

private:
	enum TDecodeState
		{
		EStateStart,
		EStateDrawFrame
		};

	TDecodeState iState;
	TFrameState iCodecState;

	TBool iJFIFMarkerPresent;
	TBool iAdobeMarkerPresent;
	TInt iAdobeTransform;

	RPointerArray<HBufC8> iComment;

	TInt iImageType;
	CPluginExtensionManager* iExtensionManager;	// owned
	CStreamedDecodeExtension* iStreamedDecodeExt;
	TUint16 iAutoRotateFlag;
	};

// Concrete Streamed Decode Extension class
class CStreamedDecodeExtension : public CBase,
								 public MImageConvStreamedDecode
	{
public:
	static CStreamedDecodeExtension* NewL(CJpegDecoder* aJpegDecoder);
	~CStreamedDecodeExtension();

	// From MImageConvStreamedDecode
	TUid Uid() const;
	void IncrementRef();
	void Release();
	void GetSupportedFormatsL(RArray<TUid>& aFormats, TUid& aOptimalFormat) const;
	void GetCapabilities(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps& aCaps) const;
	TInt GetBufferSize(TUid aFormat, TSize& aBlockSizeInPixels, TInt aNumBlocks) const;
	void InitFrameL(TUid aFormat, TInt aFrameNumber, TDecodeStreamCaps::TNavigation aNavigation);
	void GetBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aSeqPosition, TInt aNumBlocksToGet, TInt* aNumBlocksRead);
	void GetNextBlocks(TRequestStatus* aStatus, CImageFrame* aFrame, TInt aNumBlocksToGet, TInt* aNumBlocksRead, TBool* aHaveMoreBlocks);

protected:
	CStreamedDecodeExtension(CJpegDecoder* aJpegDecoder);

private:
	CJpegDecoder* iJpegDecoder;
	TInt iReferenceCount;
	};

// CJpegEncoder
class CJpgWriteCodec;
class CExifEncoder;
class CBitmapScaler;
class CEncodeOperationExtension;
class CStreamedEncodeExtension;
class CJpegEncoder : public CJPEGImageFrameEncoderPlugin
	{
public:
	static CJpegEncoder* NewL();
	~CJpegEncoder();
	// From CImageEncoderPlugin
	void PrepareEncoderL(const CFrameImageData* aFrameData);
	void UpdateHeaderL();
	void SetThumbnail(TBool aDoGenerateThumbnail);
	void Cleanup();
	MExifMetadata* ExifMetadata();

	// entension operations
	void GetExtensionL(TUid aExtUid, MImageConvExtension*& aExtPtr);
	//enum used to check and exclude interoperability of stream and operation interfaces.
	enum TExtensionOperation
		{
		ENone,
		EOperationEncode,
		EStreamEncode
		};
	CJpegEncoder::TExtensionOperation GetActiveExtensionOperation() const;
	void SetActiveExtensionOperation(CJpegEncoder::TExtensionOperation aExtOperation);

	void HandleStreamInitFrameL(TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, const CFrameImageData* aFrameImageData);
	void HandleStreamAppendBlock(const CImageFrame& aBlocks, TInt aNumBlocksToAdd);
	void HandleStreamAddBlock(const CImageFrame& aBlocks, const TInt& aSeqPosition);
	void HandleStreamCompleteFrame();

protected:
	void WriteThumbnailL();
	void WriteExifDataL(TRequestStatus*& aScaleCompletionStatus);
	void InitConvertL();
	void InitCustomAsyncL(TInt aParam);

private:
	CJpegEncoder();
	void ConstructL();

	TInt WriteImageHeaderL();
	void CreateScaledBitmapL(TRequestStatus*& aScaleCompletionStatus);
	TInt WriteThumbnailDataL();
	TInt WriteThumbnailAsJfifL(CFbsBitmap& aBitmap);
	TInt WriteThumbnailAsExifL(CFbsBitmap& aBitmap);
	TInt WriteEOIL(const TInt aPosition);
	TInt WriteSOIL(const TInt aPosition);
	void TransformBitmapL(CFbsBitmap& aSource, CFbsBitmap& aDest);

	// Handle async command for EOptionConvertFrame
	void HandleConvertFrameL();

protected:
	CExifEncoder* iExifEncoder;

private:
	TJpgFrameInfo iFrameInfo;
	TInt iQualityFactor;
	TQTable *iLumaTable;
	TQTable *iChromaTable;
	RPointerArray<HBufC8> iComment;

	CFbsBitmap* iThumbnailImage;
	CFbsBitmap* iSourceThumbnailImage;
	CBitmapScaler* iBitmapScaler;

	TInt iExifDataPosition;
	TUint iThumbnailSize;
	TUint iExifSize;

	TBool iGenerateThumbnail;
	TInt  iThumbnailStatus;
	TSize iGeneratedThumbnailSize;

	CEncodeOperationExtension* iOperationExtPtr;
	CStreamedEncodeExtension* iStreamedEncodeExt;

	TExtensionOperation iExtOperationActive;
	};

// Concrete Encode Transform Extension class
class CEncodeOperationExtension : public CBase,
								  public MImageConvOperation
	{
friend class CJpegEncoder;

public:
	static CEncodeOperationExtension* NewL(CJpegEncoder* aJpegEncoder);
	~CEncodeOperationExtension();

	// From MImageConvOperation
	TUid Uid() const;
	void IncrementRef();
	void Release();
	TUint Capabilities() const;
	void AddOperationL(TImageConvOperation::TOperation aOperation);
	void ClearOperationStack();

protected:
	CEncodeOperationExtension(CJpegEncoder* aJpegEncoder);

private:
	CJpegEncoder* iJpegEncoder;
	TInt iReferenceCount;
	TUint iOperationCaps;
	RArray<TUint> iImgConvOperations;
	};

// Concrete Streamed Encode Extension class
class CStreamedEncodeExtension : public CBase,
								 public MImageConvStreamedEncode
	{
public:
	static CStreamedEncodeExtension* NewL(CJpegEncoder* aJpegEncoder);
	~CStreamedEncodeExtension();

	// From MImageConvStreamedEncode
	TUid Uid() const;
	void IncrementRef();
	void Release();
	void GetSupportedFormatsL(RArray<TUid>& aFormats, TUid& aOptimalFormat) const;
	void GetCapabilities(TUid aFormat, TEncodeStreamCaps& aCaps) const;
	void InitFrameL(TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, TEncodeStreamCaps::TNavigation aNavigation, const CFrameImageData* aFrameImageData);
	void AppendBlocks(TRequestStatus* aReq, const CImageFrame& aBlocks, TInt aNumBlocksToAdd);
	void AddBlocks(TRequestStatus* aReq, const CImageFrame& aBlocks, const TInt& aSeqPosition);
	void Complete(TRequestStatus* aReq);

	void ValidateInitParamsL(TUid& aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, TEncodeStreamCaps::TNavigation aNavigation, const CFrameImageData* aFrameImageData);
protected:
	CStreamedEncodeExtension(CJpegEncoder* aJpegEncoder);

private:
	CJpegEncoder* iJpegEncoder;
	TInt iReferenceCount;
	TEncodeStreamCaps iEncodeCaps;
	};

#endif // __JPEGCONVERT_H__