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

//

#include <e32base.h>

#include "JpegTypes.h"

/**

	@file

	@internalComponent

*/

// THuffmanTable

THuffmanTable::THuffmanTable():

	iLastCode(0),

	iState(EUnInitialised)

	{

	// current implementation doesn't support more than 8 bit

	ASSERT(KJpgHuffmanLookAhead <= sizeof(TUint8)*8 );

	}

TInt THuffmanTable::SetL(const TUint8* aData, const TUint8* aDataLimit)

	{

	//We assume that a complete table is passed

	//If there is not enougth data the table is corrupt

	if(aData+KJpgHuffmanTableBitsSize > aDataLimit)

		{

		User::Leave(KErrCorrupt);

		}

	Mem::Copy(iBits,aData,KJpgHuffmanTableBitsSize);

	aData += KJpgHuffmanTableBitsSize;

	TInt valuesSize = 0;

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

		{

		valuesSize += iBits[count];

		}

	if((valuesSize <= 0) || (valuesSize > KJpgHuffmanTableSize) || (aData+valuesSize > aDataLimit)) 

		{

		User::Leave(KErrCorrupt);

		}

	Mem::Copy(iValues,aData,valuesSize);

	Mem::FillZ(iValues + valuesSize,KJpgHuffmanTableSize - valuesSize);

	SetState(EInitialised);

	return KJpgHuffmanTableBitsSize + valuesSize;

	}

TInt THuffmanTable::GetL(TUint8* aData)

	{

	Mem::Copy(aData,iBits,KJpgHuffmanTableBitsSize);

	aData += KJpgHuffmanTableBitsSize;

	TInt valuesSize = 0;

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

		{

		valuesSize += iBits[count];

		}

	if ((valuesSize <= 0) || (valuesSize > KJpgHuffmanTableSize)) 

		{

		User::Leave(KErrCorrupt);

		}

	Mem::Copy(aData,iValues,valuesSize);

	return KJpgHuffmanTableBitsSize + valuesSize;

	}

void THuffmanTable::GenerateSizes(THuffmanCode* aCode)

	{

	TInt i = 0;

	TInt j = 1;

	TInt k = 0;

	while (i < KJpgHuffmanTableBitsSize)

		{

		if (j > iBits[i])

			{

			i++;

			j = 1;

			}

		else

			{

			if (k == KJpgHuffmanTableSize - 1 )

			    {

			    break; // to prevent table overrun by a malicious image

			    }

			aCode[k].iSize = i + 1;

			k++;

			j++;

			}

		}

	aCode[k].iSize = 0;

	iLastCode = k - 1;

	}

void THuffmanTable::GenerateCodes(THuffmanCode* aCode)

	{

	TInt k = 0;

	TUint16 code = 0;

	TInt si = aCode[0].iSize;

	FOREVER

		{

		do	{

			aCode[k].iCode = code;

			aCode[k].iValue = iValues[k];

			code++;

			k++;

			}

		while (aCode[k].iSize == si);

		if (aCode[k].iSize == 0 || k > iLastCode)

		    {

		    break;

		    }

		do	{

			code <<= 1;

			si++;

			}

		while (aCode[k].iSize != si || si > KJpgHuffmanTableBitsSize);

		}

	}

/**

	Implemetation of TKey parameter class

	for use in User::QuickSort. 

	Sort by "iValue" member of the THuffmanTable::THuffmanCode

*/	

class THuffmanValueKey : public TKey

	{

public:

	explicit THuffmanValueKey(THuffmanTable::THuffmanCode* aArray);

	TInt Compare(TInt aLeft, TInt aRight) const;

	TAny *At(TInt anIndex) const;

protected:

	THuffmanTable::THuffmanCode* iArray;

	};	

inline

THuffmanValueKey::THuffmanValueKey(THuffmanTable::THuffmanCode* aArray)

	{

	iArray = aArray;

	}

TInt THuffmanValueKey::Compare(TInt aLeft, TInt aRight) const

	{

	return iArray[aLeft].iValue - iArray[aRight].iValue;

	}

TAny* THuffmanValueKey::At(TInt anIndex) const

	{

	return iArray + anIndex;

	}

/**

	Implemetation of TKey parameter class

	for use in User::QuickSort. 

	Sort by "iIndex" member of the THuffmanTable::THuffmanCode

*/

class THuffmanIndexKey : public TKey

	{

public:

	explicit THuffmanIndexKey(THuffmanTable::THuffmanCode* aArray);

	TInt Compare(TInt aLeft, TInt aRight) const;

	TAny *At(TInt anIndex) const;

protected:

	THuffmanTable::THuffmanCode* iArray;

	};

inline

THuffmanIndexKey::THuffmanIndexKey(THuffmanTable::THuffmanCode* aArray)

	{

	iArray = aArray;

	}

TInt THuffmanIndexKey::Compare(TInt aLeft, TInt aRight) const

	{

	return iArray[aLeft].iIndex - iArray[aRight].iIndex;

	}

TAny* THuffmanIndexKey::At(TInt anIndex) const

	{

	return iArray + anIndex;

	}

/**

	Implemetation of TSwap parameter class

	for use in User::QuickSort. 

	Swaps two THuffmanTable::THuffmanCode variables

*/

class THuffmanCodeSwap : public TSwap

	{

public:

	explicit THuffmanCodeSwap(THuffmanTable::THuffmanCode* aArray);

	void Swap(TInt aLeft, TInt aRight) const;

protected:

	THuffmanTable::THuffmanCode* iArray;

	};

inline

THuffmanCodeSwap::THuffmanCodeSwap(THuffmanTable::THuffmanCode* aArray)

	{

	iArray = aArray;

	}

void THuffmanCodeSwap::Swap(TInt aLeft, TInt aRight) const

	{

	THuffmanTable::THuffmanCode tmp=iArray[aLeft];

	iArray[aLeft] 	= iArray[aRight];

	iArray[aRight] 	= tmp;

	}

void THuffmanTable::SortByCode(THuffmanTable::THuffmanCode* aCode, TUint8* aBitsToCodeIdxHash)

	{

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

		{

		THuffmanCode& codeEntry = aCode[count];

		aCode[count].iIndex = (1 << codeEntry.iSize) - 1 + codeEntry.iCode;

		}

	THuffmanIndexKey key(aCode);

	THuffmanCodeSwap swap(aCode);

	User::QuickSort(iLastCode+1, key, swap);

	aBitsToCodeIdxHash[0]=0;

	TInt sz=0;

	for (TInt j=0; j <= iLastCode; ++j)

		{

		if (aCode[j].iSize > sz)

			{

			TInt k=sz+1;

			sz = aCode[j].iSize;

			for (; k<=sz; ++k)

				{

				aBitsToCodeIdxHash[k]=j;

				}

			}

		}

	aBitsToCodeIdxHash[sz+1]=iLastCode;

	}

class THuffmanValueSwap : public TSwap

	{

public:

	explicit THuffmanValueSwap(THuffmanTable::THuffmanCode* aArray);

	void Swap(TInt aLeft, TInt aRight) const;

protected:

	THuffmanTable::THuffmanCode* iArray;

	};

inline

THuffmanValueSwap::THuffmanValueSwap(THuffmanTable::THuffmanCode* aArray)

	{

	iArray = aArray;

	}

void THuffmanValueSwap::Swap(TInt aLeft, TInt aRight) const

	{

	THuffmanTable::THuffmanCode tmp=iArray[aLeft];

	iArray[aLeft] 	= iArray[aRight];

	iArray[aRight] 	= tmp;

	}

void THuffmanTable::SortByValue(THuffmanTable::THuffmanCode* aArray)

	{

	THuffmanValueKey key(aArray);

	THuffmanValueSwap swap(aArray);

	User::QuickSort(iLastCode+1, key, swap);

	}

void TDecHuffmanTable::MakeDerivedTableL()

	{

	if(State()!=EInitialised)

		{

		return;

		}

	THuffmanCode* codes = (THuffmanCode*)User::AllocZ(KJpgHuffmanTableSize*sizeof(THuffmanCode));

	if (codes == NULL) 

		{

		User::Leave(KErrNoMemory);

		}

	CleanupStack::PushL(codes);

	Mem::FillZ(iLookupTable, KJpgHuffmanTableSize * sizeof(TUint16));

	Mem::FillZ(iValue, KJpgHuffmanTableSize * sizeof(TUint16));

	Mem::FillZ(iIndex, KJpgHuffmanTableSize * sizeof(TInt));

	GenerateSizes(codes);

	if (iLastCode < 0 || iLastCode >= KJpgHuffmanTableSize) 

		{

		User::Leave(KErrCorrupt);	

		}

	GenerateCodes(codes);

	TInt p = 0;

    for (TUint l = 1; l <= KJpgHuffmanLookAhead; l++)

    	{

    	for (TUint i = 1; i <= iBits[l-1]; i++, p++)

    		{

    		// l = current code's length, p = its index in huffcode[] & huffval[].

    		// Generate left-justified code followed by all possible bit sequences

    		TInt lookbits = codes[p].iCode << (KJpgHuffmanLookAhead-l);

    		for (TInt ctr = 1 << (KJpgHuffmanLookAhead-l); ctr > 0; ctr--)

    				{

    				iLookupTable[lookbits] = ((l << 8) | iValues[p]);

    				lookbits++;

    				}

    		}

		}

	SortByCode(codes, iBitsToCodeIdxHash);

	for (TInt i = 0; i < iLastCode+1; i++) 

		{

		iValue[i] = codes[i].iValue;

		iIndex[i] = codes[i].iIndex;

		}

	CleanupStack::PopAndDestroy();

	SetState(EParsed);

	}

template <TInt aTableSize> void TEncHuffmanTable<aTableSize>::MakeDerivedTableL()

	{

	if(State()!=EInitialised)

		{

		return;

		}

	THuffmanCode* codes = (THuffmanCode*)User::AllocZ(KJpgHuffmanTableSize*sizeof(THuffmanCode));

	if (codes == NULL) 

		{

		User::Leave(KErrNoMemory);

		}

	CleanupStack::PushL(codes);

	Mem::FillZ(codes, KJpgHuffmanTableSize * sizeof(THuffmanCode));

	Mem::FillZ(iLookupTable, aTableSize * sizeof(TUint32));

	GenerateSizes(codes);

	if (iLastCode < 0 || iLastCode >= KJpgHuffmanTableSize) 

		{

		User::Leave(KErrCorrupt);	

		}

	GenerateCodes(codes);

	SortByValue(codes);

	for (TInt i=iLastCode; i; --i)

		{

		ASSERT( codes[i].iValue <= aTableSize );

		codes[codes[i].iValue] = codes[i];

		}

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

		{

		TInt value = iValues[i];

		iLookupTable[value] = (codes[value].iSize | (codes[value].iCode << 16));

		}

	CleanupStack::PopAndDestroy();

	SetState(EParsed);

	}

const TInt KEncDCHTSize = 11;// the defines from jpegwritecodec.h 

const TInt KEncACHTSize = 0xFA;

template class TEncHuffmanTable<KEncDCHTSize+1>;

template class TEncHuffmanTable<KEncACHTSize+1>; //templates for jpegwritecodec

void THuffmanTableProcessor::ProcessHuffmanTableL(const TUint8*& aDataPtr, const TUint8* aDataPtrLimit, TDecHuffmanTable* aDCTable, TDecHuffmanTable* aACTable)

	{

	while (aDataPtr < aDataPtrLimit)

		{

		TInt index = *aDataPtr++;

		TBool dcTable = !(index & 0x10);

		index &= 0x0f;

		if (index >= KJpgMaxNumberOfTables)

			User::Leave(KErrCorrupt);

		TDecHuffmanTable& table = dcTable ? aDCTable[index] : aACTable[index];

		aDataPtr += table.SetL(aDataPtr, aDataPtrLimit);

		}

	//The block length and actual data did not match 

	if(aDataPtr != aDataPtrLimit)

		User::Leave(KErrCorrupt);	

	}

/**

 Before calling this function, the Huffman tables should be set.

 */

void TJpgScanInfoProcessor::ProcessStartOfScanL(const TUint8*& aPtr, const TJpgFrameInfo& aJpgFrameInfo, TJpgScanInfo& aScanInfo, TDecHuffmanTable* aDCTable, TDecHuffmanTable* aACTable)

	{

	aScanInfo.iNumberOfComponents = *aPtr++;

	//At least one component and not more than specified in the start of frame header

	if(aScanInfo.iNumberOfComponents < KJpgMinNumberOfComponents || aScanInfo.iNumberOfComponents > aJpgFrameInfo.iNumberOfComponents)

		User::Leave(KErrCorrupt);

	for (TInt count = 0; count < aScanInfo.iNumberOfComponents; count++)

		{

		aScanInfo.iComponent[count].iId = *aPtr++;

		TUint8 table = *aPtr++;

		TUint8 DCTable = static_cast<TUint8>(table >> 4);

		TUint8 ACTable = static_cast<TUint8>(table & 0x0f);

		if(DCTable > KJpgMaxNumberOfTables || ACTable > KJpgMaxNumberOfTables)

			User::Leave(KErrCorrupt);

		aScanInfo.iComponent[count].iDCCodingTable = DCTable;

		aScanInfo.iComponent[count].iACCodingTable = ACTable;

		aDCTable[DCTable].MakeDerivedTableL();

		aACTable[ACTable].MakeDerivedTableL();

		}

	aScanInfo.iStartSpectralSelection = *aPtr++;

	aScanInfo.iEndSpectralSelection = *aPtr++;

	TUint8 successiveApproximation = *aPtr;

	aScanInfo.iSuccessiveApproximationBitsHigh = successiveApproximation >> 4;

	aScanInfo.iSuccessiveApproximationBitsLow = successiveApproximation & 0x0f;

	}