// Copyright (c) 2006-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 JPEGWRITECODEC_H

#define JPEGWRITECODEC_H

/**
   @file
   @internalComponent
*/
//#define PROFILE_JPEG_ENCODER 1
#include "imgpositionprocessor.h"
#include "JpegTypes.h"

class TPositionProcessor;
class CRgbBufferPtr;
class CImageFrame;
class CJpgImageFrameWriteCodec;
class CJpgImageFrameProcessor;
class TDataUnit;
class TQTable;


const TInt KEncDCHTSize = 11;
const TInt KEncACHTSize = 0xFA;

// CJpgWriteCodec
class CJpgWriteCodec : public CImageWriteCodec
	{
public:

	static CJpgWriteCodec* NewL(const TJpgFrameInfo& aFrameInfo,TInt aQualityFactor,TQTable* aReplacementLumaQTable,TQTable* aReplacementChromaQTable,const RPointerArray<HBufC8>& aComment,RArray<TUint>* aOperationsRequested);
	
	virtual ~CJpgWriteCodec();

	// Jpg codec support for Image Frame
	void InitFrameL(TBufPtr8& aDst, const CImageFrame* aFrame, const CFrameImageData* aFrameImageData);

	// Jpg codec support for Image Frame streaming
	void InitFrameL(TBufPtr8& aDst, TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, const CFrameImageData* aFrameImageData);
	void AppendFrameBlockL(const CImageFrame& aBlocks, TInt aNumBlocksToAdd);
	void CompleteFrame();
	void SetCompleteFrame();
	
	static void InitTransformCoordinates(TPositionProcessor& aPosProcessor, const TRect& aSourceRect, const TSize& aMCUSize, const RArray<TUint>& aOperationsRequested);
	static void ValidateBlockSizeL(const TSize& aBlockSizeInPixels, const TSize& aRefSizeInPixels);
	void SetHighSpeedMode(TBool aHighSpeedMode);
protected:
	CJpgWriteCodec(const TJpgFrameInfo& aFrameInfo,TInt aQualityFactor,TQTable* aReplacementLumaQTable,TQTable* aReplacementChromaQTable,const RPointerArray<HBufC8>& aComment);
	void ConstructL(RArray<TUint>* aOperationsRequested);
	
	virtual TFrameState ProcessFrameL(TBufPtr8& aSrc);
	virtual void InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource);
	void CodecInfoL();
	void WriteInfoL();
	void DoProcessL();
	void InitCompConfig();
	CRgbBufferPtr::TConstRgbBufferPtr GetPixels(const TPoint& aPos);
	void WriteDataUnitL(const TDataUnit& aDataUnit,const TEncHuffmanTable<KEncDCHTSize+1>& aDCTable,const TEncHuffmanTable<KEncACHTSize+1>& aACTable,TInt& aDCPredictor);
	inline TUint32 WriteBitsFast(TUint32 aValue, TInt aNumBits, TUint32& aBitBuffer, TInt aBitsUsed);
	void WriteBits(TUint32 aBitBuffer);
	
	void InitTransformationL(TPositionProcessor& aPosProcessor, const TRect& aSourceRect, const TSize& aMCUSize, TJpgFrameInfo& aFrameInfo, const TInt aDataUnitCount);
	void InitTransformDataUnitIndex(TInt aDataUnitCount);
	void InitTransformDataUnitCoeff(TUint8* aDestination);
	void TransformDataUnitCoeff(TDataUnit& aDestination, const TDataUnit& aSource);
	TInt GetIndexFromPos(const TPoint& aPos);
	
private:
    typedef TUint32 TBitBufferType;
	TUint8* iDestPtr;
	TUint8* iDestPtrLimit;
	TInt iBitsUsed;
	//Must be TUint32
	TUint32 iBitBuffer;

protected:
	TInt iDCPredictor[KJpgNumberOfComponents];
	
	TRect iSourceRect;
	TPoint iPos;

	TInt iQualityFactor;
	TEncHuffmanTable<KEncDCHTSize+1> iLumaDCHuffmanTable;
	TEncHuffmanTable<KEncDCHTSize+1> iChromaDCHuffmanTable;
	TEncHuffmanTable<KEncACHTSize+1> iLumaACHuffmanTable;
	TEncHuffmanTable<KEncACHTSize+1> iChromaACHuffmanTable;
	TQTable iLumaQTable;
	TQTable iChromaQTable;
	TQTable* iReplacementLumaQTable;
	TQTable* iReplacementChromaQTable;
	TDCT iDCT;	

	TSize iMCUSizeInPixels;
	
	TDataUnitProcessor* iDataUnitProcessor;
	TInt iDataUnitCount;
	
	// Jpg codec support for Image Frame
	CJpgImageFrameWriteCodec* iImageFrameCodecPtr;	
	
	// Jpg support for rotate and flip encode
	TPositionProcessor iPosProcessor;
	TUint8 iTransformedDUIdx[KJpgMaxNumOfDataUnits];
	RArray<TUint> iOperationsRequested;
	TUint8 iTransformDUCoeffIdx[KJpgDCTBlockSize];
	
	// Jpg codec support for Image Frame streaming
	TBool iIsBlockStreaming;
    class TStreamConfig
        {
    public:
		TInt iNumOfBlocksToAppend;
		TInt iNumOfBlocksAppended;
		TInt iNumOfMCUsProcessed;
		TBool iIsFrameComplete;
        };
	TStreamConfig iStreamConfig;
		
    class TSpecialDataUnit: public TDataUnit
        {
    public:
        TDataUnit::TDataUnitElemType iExtraElement;
        };
    
    class TComponentConfig
        {
    public:
        TEncHuffmanTable<KEncACHTSize+1>*  iACTable;
        TEncHuffmanTable<KEncDCHTSize+1>*  iDCTable;
        TQTable*        iQTTable;
        TInt            iDataUnitsCount;
        TInt            iDCPredictorIdx;
        TInt            iFirstDUIdx;
        };
    
	TComponentConfig iCompConfig[ KJpgNumberOfComponents ];
	TSpecialDataUnit iQuantizeTarget[ KJpgMaxNumOfDataUnits ];
	TInt iWrittingDUIdx;
	
	CRgbBufferPtr* iRgbInputBuffer;
	TJpgFrameInfo iFrameInfo;
	const RPointerArray<HBufC8> &iComment;
#if defined(PROFILE_JPEG_ENCODER)
	TUint iGetPixelsTime;
	TUint iDataUnitProcessTime;
	TUint iTransforTime;
	TUint iQuantizeTime;
	TUint iWriteDataUnitTime;
	TUint iImageFrameTime;
	TUint iOverallTime;
#endif	
	TBool iHighSpeedMode;			// flag for "fast encoding mode"	
	};


// CImageFrameWriteCodec
class CJpgImageFrameWriteCodec : public CBase
	{
public:
	static CJpgImageFrameWriteCodec* NewL(const CImageFrame* aFrame);
	~CJpgImageFrameWriteCodec();

	void CreateImageProcessorL();
	void PrepareFrameInfoL(TJpgFrameInfo& aFrameInfo, const CFrameImageData* aFrameImageData);
	void SetPosition(TPoint& aPos);
	void Position(TPoint& aPos);
	TDataUnit* ProcessL();
	TInt DataUnitCount() const;
	void InitFrameCompInfoL(TJpgFrameInfo& aFrameInfo);
	TJpegImageData::TColorSampling GetColorSamplingL(TUid aFormat);
	TUid GetSamplingSchemeL(TUid aFormat);
	
	// for streaming
	void PrepareFrameImageDataInfoL(TJpgFrameInfo& aFrameInfo, TUid aFormat, TInt aFrameNumber, const CFrameImageData* aFrameImageData);
	void AppendImageFrameBlockL(const CImageFrame* aFrame);	
	TSize ImageFrameSize() const;
	TUid SamplingScheme() const;
	
private:
	CJpgImageFrameWriteCodec(const CImageFrame* aFrame);

private:
	const CImageFrame* iSource;
	CJpgImageFrameProcessor* iImageFrameProcessorPtr;
	TInt iDataUnitCount;
	TUid iSampleScheme;
	};

#endif // ndef JPEGWRITECODEC_H