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

//

/**

 @file

 @internalComponent

*/

#include <e32base.h>

#include "icl/ImageCodec.h"

#include "JpegTypes.h"

#include "rgbbufferptr.h"

#include "jpgimageframeprocessor.h"

#include "jpegwritecodec.h"

const TInt KDataUnitSafeBufferSz = sizeof(TDataUnit) + ( sizeof(TDataUnit) >> 1 ); // sizeof(TDataUnit) * 1.5

// Encoder tables.

static const TUint8 KLuminanceQTableValues[] = {

	16,  11,  12,  14,  12,  10,  16,  14,

	13,  14,  18,  17,  16,  19,  24,  40,

	26,  24,  22,  22,  24,  49,  35,  37,

	29,  40,  58,  51,  61,  60,  57,  51,

	56,  55,  64,  72,  92,  78,  64,  68,

	87,  69,  55,  56,  80,  109, 81,  87,

	95,  98,  103, 104, 103, 62,  77,  113,

	121, 112, 100, 120, 92,  101, 103, 99 };

static const TUint8 KChrominanceQTableValues[] = {

	17,  18,  18,  24,  21,  24,  47,  26,

	26,  47,  99,  66,  56,  66,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99,

	99,  99,  99,  99,  99,  99,  99,  99 };

static const TUint8 KLuminanceDCHuffmanValues[] = {

// Number of codes per bit-length

//  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 

	0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,

// source byte definitions

	0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11 };

static const TUint8 KChrominanceDCHuffmanValues[] = {

// Number of codes per bit-length

//  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 

	0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,

// source byte definitions

	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };

static const TUint8 KLuminanceACHuffmanValues[] = {

// Number of codes per bit-length

//  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 

	0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d,

	0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,

	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,

	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,

	0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,

	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,

	0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,

	0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,

	0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,

	0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,

	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

	0xf9, 0xfa };

static const TUint8 KChrominanceACHuffmanValues[] = {

    // Number of codes per bit-length

	0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77,

	// Code value definitions

	0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,

	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,

	0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,

	0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,

	0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,

	0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,

	0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,

	0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,

	0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,

	0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,

	0xf9, 0xfa };

#if defined(PROFILE_JPEG_ENCODER)

#define PROFILE_START(a)\

			TUint a##_Start=User::FastCounter();

#define PROFILE_END(aa) aa += User::FastCounter() - aa##_Start;

#define PROFILE_MARK(aa) aa = User::FastCounter() - aa;			

#define PROFILE_REPORT(a)\

		RDebug::Printf("--Profile: %s\t%d",#a, a);

#else

#define PROFILE_START(a)

#define PROFILE_END(a)

#define PROFILE_REPORT(a)

#define PROFILE_MARK(a)

#endif

// CJpegWriteCodec

CJpgWriteCodec::CJpgWriteCodec(const TJpgFrameInfo& aFrameInfo,TInt aQualityFactor,TQTable* aReplacementLumaQTable,TQTable* aReplacementChromaQTable,const RPointerArray<HBufC8>& aComment)

	: iQualityFactor(aQualityFactor), iReplacementLumaQTable(aReplacementLumaQTable), iReplacementChromaQTable(aReplacementChromaQTable), iFrameInfo(aFrameInfo), iComment(aComment)

	{

	iWrittingDUIdx = KJpgMaxNumOfDataUnits;

// check that CJpgWriteCodec::TSpecialDataUnit has the right size, as we rely on that

// if it doesn't throw a compile-time error

    ASSERT( ( _FOFF(CJpgWriteCodec::TSpecialDataUnit,iExtraElement) == sizeof(TDataUnit) ) );

	}

CJpgWriteCodec::~CJpgWriteCodec()

	{

	iOperationsRequested.Close();

	delete iRgbInputBuffer;

	delete iDataUnitProcessor;

	delete iImageFrameCodecPtr;

	}

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

	{

	CJpgWriteCodec* self = new(ELeave) CJpgWriteCodec(aFrameInfo, aQualityFactor, aReplacementLumaQTable, aReplacementChromaQTable, aComment);

	CleanupStack::PushL(self);

	self->ConstructL(aOperationsRequested);

	CleanupStack::Pop(self); 

	return self;

	}

void CJpgWriteCodec::ConstructL(RArray<TUint>* aOperationsRequested)

	{

	if(!aOperationsRequested)

		{

		iOperationsRequested.Reset();		

		}

	else

		{

		TInt count = aOperationsRequested->Count();

		for (TInt i = 0; i<count; i++)

			{

			iOperationsRequested.AppendL((*aOperationsRequested)[i]);

			}						

		}

	}

void CJpgWriteCodec::SetHighSpeedMode(TBool aHighSpeedMode)

	{

	iHighSpeedMode = aHighSpeedMode;

	}

TFrameState CJpgWriteCodec::ProcessFrameL(TBufPtr8& aDst)

	{

	TFrameState state;	

	TUint8* destStartPtr = const_cast<TUint8*>(aDst.Ptr());

	iDestPtr = destStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength() - sizeof(iBitBuffer) * 2; // Subtract four to give a safety buffer

	if(iStreamConfig.iIsFrameComplete)

		{

		CompleteFrame();

		aDst.SetLength(iDestPtr - destStartPtr);

		state = EFrameComplete;

		if(iStreamConfig.iNumOfMCUsProcessed < ((iFrameInfo.iSizeInPixels.iWidth * iFrameInfo.iSizeInPixels.iHeight) / (iMCUSizeInPixels.iWidth * iMCUSizeInPixels.iHeight)))		

			{

			User::Leave(KErrUnderflow);

			}

		return state;

		}

	TRAPD(err,DoProcessL());	

	if (err != KErrNone)

		{

		if (err != KErrCompletion)

		    {

		    User::Leave(err);

		    }

		}

	state = EFrameIncomplete;

	if(iIsBlockStreaming)

		{

		if (iPosProcessor.IsEndOfImage())

			{

			state = EBlockComplete;

			}		

		}

	else

		{

		if (iPosProcessor.IsEndOfImage())

			{

			CompleteFrame();

			state = EFrameComplete;

			}

		}

    aDst.SetLength(iDestPtr - destStartPtr);		

	return state;

	}

void CJpgWriteCodec::SetCompleteFrame()

	{

	iStreamConfig.iIsFrameComplete = ETrue;

	}

void CJpgWriteCodec::CompleteFrame()

	{

	if (iBitsUsed >= 8)

	    {

	    do 

			{

			TUint8 byte = (TUint8)(iBitBuffer >> 24);

			iBitBuffer <<= 8;

			*iDestPtr++ = byte;

			if (byte == 0xff)

				{

				*iDestPtr++ = 0;

				}

			iBitsUsed   -= 8;

			} while (iBitsUsed >= 8);

	    }

	if (iBitsUsed > 0)

	    {

	    iDestPtr[0] = TUint8( iBitBuffer >> 24 );

	    ++iDestPtr;

	    }

	PROFILE_MARK(iOverallTime);

	PROFILE_REPORT(iGetPixelsTime);

	PROFILE_REPORT(iImageFrameTime);

	PROFILE_REPORT(iDataUnitProcessTime);

	PROFILE_REPORT(iTransforTime);

	PROFILE_REPORT(iQuantizeTime);

	PROFILE_REPORT(iWriteDataUnitTime);

	PROFILE_REPORT(iOverallTime);

	}

#if defined(__ARMCC__)

#pragma push

#pragma thumb

#endif

//Bitmap encoding	

void CJpgWriteCodec::InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource)

	{

	PROFILE_MARK(iOverallTime);

	TUint8* destStartPtr = const_cast<TUint8*>(aDst.Ptr());

	iDestPtr = destStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength();

	SetSource(&aSource);

	iSourceRect = TRect(aSource.SizeInPixels());

	iPos.SetXY(0,0);

	iFrameInfo.iSizeInPixels = iSourceRect.Size();

	iMCUSizeInPixels.SetSize(iFrameInfo.iMaxHorzSampleFactor,iFrameInfo.iMaxVertSampleFactor);

	iMCUSizeInPixels.iWidth     *= KJpgDCTBlockWidth;

	iMCUSizeInPixels.iHeight    *= KJpgDCTBlockWidth;

	delete iRgbInputBuffer; 

	iRgbInputBuffer = NULL;

	iRgbInputBuffer = CRgbBufferPtr::NewL(const_cast<CFbsBitmap&>(aSource), iMCUSizeInPixels);

    if (iFrameInfo.iNumberOfComponents == 1)

        {

        iDataUnitCount = 1;

        }

	else

		{

		iDataUnitCount = 0;

		for (TInt index = 0; index < iFrameInfo.iNumberOfComponents; index++)

			{

			TJpgFrameInfo::TComponentInfo& component = iFrameInfo.iComponent[index];

			iDataUnitCount += component.iHorzSampleFactor * component.iVertSampleFactor;

			}

		}

    ASSERT( iDataUnitCount <= KJpgMaxNumOfDataUnits );

	switch (iDataUnitCount)

		{

	case KJpgMonochromeDataUnitCount: // Monochrome

		iDataUnitProcessor = new(ELeave) TMonoProcessor;

		break;

	case KJpgEColor444DataUnitCount: // 4:4:4

		iDataUnitProcessor = new(ELeave) T444Processor;

		break;

	case KJpgColor422DataUnitCount: // 4:2:2

		iDataUnitProcessor = new(ELeave) T422Processor;

		break;

	case KJpgColor420DataUnitCount: // 4:2:0

		iDataUnitProcessor = new(ELeave) T420Processor;

		break;

	default:

		User::Leave(KErrNotSupported);

		}

    iDataUnitProcessor->SetBufferPtrUtil( *iRgbInputBuffer );

    InitTransformationL(iPosProcessor, iSourceRect, iMCUSizeInPixels, iFrameInfo, iDataUnitCount);

    CodecInfoL();

    InitCompConfig();

	aDst.SetLength(iDestPtr - destStartPtr);

	}

//ImageFrame encoding

void CJpgWriteCodec::InitFrameL(TBufPtr8& aDst, const CImageFrame* aFrame, const CFrameImageData* aFrameImageData)

	{

	TUint8* destStartPtr = const_cast<TUint8*>(aDst.Ptr());

	iDestPtr = destStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength();

	iSourceRect = TRect(aFrame->FrameSizeInPixels());

	iPos.SetXY(0,0);

	iFrameInfo.iSizeInPixels = iSourceRect.Size();

	// Create JPEG write codec extension and the appropriate image processor

	ASSERT( iImageFrameCodecPtr == NULL );

	delete iImageFrameCodecPtr;

	iImageFrameCodecPtr = NULL;

	iImageFrameCodecPtr = CJpgImageFrameWriteCodec::NewL(aFrame);

	iImageFrameCodecPtr->PrepareFrameInfoL(iFrameInfo, aFrameImageData);

	iImageFrameCodecPtr->CreateImageProcessorL();

	iDataUnitCount = iImageFrameCodecPtr->DataUnitCount();

	iMCUSizeInPixels.SetSize(iFrameInfo.iMaxHorzSampleFactor, iFrameInfo.iMaxVertSampleFactor);

	iMCUSizeInPixels.iWidth     *= KJpgDCTBlockWidth;

	iMCUSizeInPixels.iHeight    *= KJpgDCTBlockWidth;

	InitTransformationL(iPosProcessor, iSourceRect, iMCUSizeInPixels, iFrameInfo, iDataUnitCount);

	CodecInfoL();

	InitCompConfig();

	aDst.SetLength(iDestPtr - destStartPtr);	

	}

//ImageFrame stream encoding

void CJpgWriteCodec::InitFrameL(TBufPtr8& aDst, TUid aFormat, TInt aFrameNumber, const TSize& aFrameSizeInPixels, const TSize& aBlockSizeInPixels, const CFrameImageData* aFrameImageData)

	{

	TUint8* destStartPtr = const_cast<TUint8*>(aDst.Ptr());

	iDestPtr = destStartPtr;

	iDestPtrLimit = iDestPtr + aDst.MaxLength();

	iSourceRect = TRect(aFrameSizeInPixels);

	iPos.SetXY(0,0);

	iFrameInfo.iSizeInPixels = iSourceRect.Size();

	// Create JPEG write codec extension and the appropriate image processor

	ASSERT( iImageFrameCodecPtr == NULL );

	delete iImageFrameCodecPtr;

	iImageFrameCodecPtr = NULL;

	iImageFrameCodecPtr = CJpgImageFrameWriteCodec::NewL(NULL);

	iImageFrameCodecPtr->PrepareFrameImageDataInfoL(iFrameInfo, aFormat, aFrameNumber, aFrameImageData);

	iDataUnitCount = iImageFrameCodecPtr->DataUnitCount();

	iMCUSizeInPixels.SetSize(iFrameInfo.iMaxHorzSampleFactor, iFrameInfo.iMaxVertSampleFactor);

	iMCUSizeInPixels.iWidth     *= KJpgDCTBlockWidth;

	iMCUSizeInPixels.iHeight    *= KJpgDCTBlockWidth;

	InitTransformationL(iPosProcessor, TRect(aBlockSizeInPixels), iMCUSizeInPixels, iFrameInfo, iDataUnitCount);

	iIsBlockStreaming = ETrue;

	iStreamConfig.iIsFrameComplete = EFalse;

	CodecInfoL();

	InitCompConfig();

	aDst.SetLength(iDestPtr - destStartPtr);	

	}

void CJpgWriteCodec::AppendFrameBlockL(const CImageFrame& aBlocks, TInt aNumBlocksToAdd)

	{	

	ValidateBlockSizeL(aBlocks.FrameSizeInPixels(), iMCUSizeInPixels);

	if (aBlocks.FrameSizeInPixels().iHeight != iMCUSizeInPixels.iHeight)

		{

		User::Leave(KErrNotSupported);

		}

	iStreamConfig.iNumOfBlocksToAppend = aNumBlocksToAdd;

	iStreamConfig.iNumOfBlocksAppended = 0;

	iImageFrameCodecPtr->AppendImageFrameBlockL(&aBlocks);

	InitTransformationL(iPosProcessor, TRect(aBlocks.FrameSizeInPixels()), iMCUSizeInPixels, iFrameInfo, iDataUnitCount);

	}

//validates the stream blocks passed and checks that the height is equal to the mcu height.

void CJpgWriteCodec::ValidateBlockSizeL(const TSize& aBlockSizeInPixels, const TSize& aRefSizeInPixels)

	{

	TInt oddPixelsWidth = aBlockSizeInPixels.iWidth % aRefSizeInPixels.iWidth;

	TInt oddPixelsHeight = aBlockSizeInPixels.iHeight % aRefSizeInPixels.iHeight;	

	if (oddPixelsWidth != 0 || oddPixelsHeight != 0)

		{

		User::Leave(KErrNotSupported);

		}

	}

void CJpgWriteCodec::InitTransformationL(TPositionProcessor& aPosProcessor, const TRect& aSourceRect, const TSize& aMCUSize, TJpgFrameInfo& aFrameInfo, const TInt aDataUnitCount)

	{

    InitTransformCoordinates(aPosProcessor, aSourceRect, aMCUSize, iOperationsRequested);

    InitTransformDataUnitIndex(aDataUnitCount);

	if(aPosProcessor.IsTransformNeeded())

		{

		ValidateBlockSizeL(aFrameInfo.iSizeInPixels, aMCUSize);

		if(aPosProcessor.SwapDimensions())

		    {

		    TInt tempDimention;

			tempDimention = aFrameInfo.iSizeInPixels.iHeight; 

			aFrameInfo.iSizeInPixels.iHeight = aFrameInfo.iSizeInPixels.iWidth; // Y

			aFrameInfo.iSizeInPixels.iWidth = tempDimention; // X

			if(aDataUnitCount == KJpgColor422DataUnitCount)

				{

				tempDimention = aFrameInfo.iComponent[0].iHorzSampleFactor;

				aFrameInfo.iComponent[0].iHorzSampleFactor = aFrameInfo.iComponent[0].iVertSampleFactor;

				aFrameInfo.iComponent[0].iVertSampleFactor = tempDimention;			

				}				

		    }		

		}

	InitTransformDataUnitCoeff(iTransformDUCoeffIdx);	

	}

void CJpgWriteCodec::InitCompConfig()

    {

	iCompConfig[ KYComp ].iFirstDUIdx = 0;

	switch (iDataUnitCount)

		{

	case KJpgMonochromeDataUnitCount: // Monochrome

		// in fact we don't have these comps for mono, so assign them last index

		iCompConfig[ KUComp ].iFirstDUIdx = KJpgMaxNumOfDataUnits - 1;

		iCompConfig[ KVComp ].iFirstDUIdx = KJpgMaxNumOfDataUnits - 1;		

		break;

	case KJpgEColor444DataUnitCount: // 4:4:4

		iCompConfig[ KUComp ].iFirstDUIdx = 1;

		iCompConfig[ KVComp ].iFirstDUIdx = 2;

		break;

	case KJpgColor422DataUnitCount: // 4:2:2

		iCompConfig[ KUComp ].iFirstDUIdx = 2;

		iCompConfig[ KVComp ].iFirstDUIdx = 3;		

		break;

	case KJpgColor420DataUnitCount: // 4:2:0

		iCompConfig[ KUComp ].iFirstDUIdx = 4;

		iCompConfig[ KVComp ].iFirstDUIdx = 5;				

		break;

	default:

		ASSERT( EFalse ); // shan't happen

		}

	iCompConfig[ KYComp ].iDCPredictorIdx = KYComp;

	iCompConfig[ KUComp ].iDCPredictorIdx = KUComp;

	iCompConfig[ KVComp ].iDCPredictorIdx = KVComp;

    TJpgFrameInfo::TComponentInfo& yComp    = iFrameInfo.iComponent[ KYComp ];

	iCompConfig[ KYComp ].iDataUnitsCount     = yComp.iHorzSampleFactor * yComp.iVertSampleFactor;

	if (iCompConfig[ KYComp ].iDataUnitsCount == 3)

		{

		TJpgFrameInfo::TComponentInfo& uComp = iFrameInfo.iComponent[ KUComp ];

		iCompConfig[ KUComp ].iDataUnitsCount = uComp.iHorzSampleFactor * uComp.iVertSampleFactor;

		TJpgFrameInfo::TComponentInfo& vComp = iFrameInfo.iComponent[ KVComp ];

		iCompConfig[ KVComp ].iDataUnitsCount = vComp.iHorzSampleFactor * vComp.iVertSampleFactor;

		}

	else

	    {

	    iCompConfig[ KVComp ].iDataUnitsCount = iCompConfig[ KUComp ].iDataUnitsCount = 0;

	    }

	iCompConfig[ KYComp ].iACTable = &iLumaACHuffmanTable;

	iCompConfig[ KYComp ].iDCTable = &iLumaDCHuffmanTable;

	// we use the same tables for U and V comps

	iCompConfig[ KUComp ].iACTable = &iChromaACHuffmanTable;

	iCompConfig[ KUComp ].iDCTable = &iChromaDCHuffmanTable;

	iCompConfig[ KVComp ].iACTable = &iChromaACHuffmanTable;

	iCompConfig[ KVComp ].iDCTable = &iChromaDCHuffmanTable;

	iCompConfig[ KYComp ].iQTTable = &iLumaQTable;

	// we use the same tables for U and V comps

	iCompConfig[ KUComp ].iQTTable = &iChromaQTable;

	iCompConfig[ KVComp ].iQTTable = &iChromaQTable;

	iBitsUsed = 0;

    iBitBuffer= 0;    

    }