// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // f32\sfile\sf_inflate.h

 // 

 //

 #include "sf_deflate.h"

 #include "sf_ldr.h"

 // Class RInflater

 //

 // The inflation algorithm, complete with huffman decoding

 inline CInflater::CInflater(TBitInput& aInput)

 	:iBits(&aInput),iEncoding(0),iOut(0)

 	{}

 void CInflater::ConstructL()

 	{

 	iEncoding=new(ELeave) TEncoding;

 	InitL();

 	iLen=0;

 	iOut=new(ELeave) TUint8[KDeflateMaxDistance];

 	iAvail=iLimit=iOut;

 	}

 CInflater* CInflater::NewLC(TBitInput& aInput)

 	{

 	CInflater* self=new(ELeave) CInflater(aInput);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 CInflater::~CInflater()

 	{

 	delete iEncoding;

 	delete [] iOut;

 	}

 TInt CInflater::ReadL(TUint8* aBuffer,TInt aLength, TMemoryMoveFunction aMemMovefn)

 	{

 	TInt tfr=0;

 	for (;;)

 		{

 		TInt len=Min(aLength,iLimit-iAvail);

 		if (len && aBuffer)

 			{

 			aMemMovefn(aBuffer,iAvail,len);

 			aBuffer+=len;

 			}

 		aLength-=len;

 		iAvail+=len;

 		tfr+=len;

 		if (aLength==0)

 			return tfr;

 		len=InflateL();

 		if (len==0)

 			return tfr;

 		iAvail=iOut;

 		iLimit=iAvail+len;

 		}

 	}

 TInt CInflater::SkipL(TInt aLength)

 	{

 	return ReadL(0,aLength,Mem::Move);

 	}

 void CInflater::InitL()

 	{

 // read the encoding

 	Huffman::InternalizeL(*iBits,iEncoding->iLitLen,KDeflationCodes);

 // validate the encoding

 	if (!Huffman::IsValid(iEncoding->iLitLen,TEncoding::ELitLens) ||

 		!Huffman::IsValid(iEncoding->iDistance,TEncoding::EDistances))

 		LEAVE_FAILURE(KErrCorrupt);

 // convert the length tables into huffman decoding trees

 	Huffman::Decoding(iEncoding->iLitLen,TEncoding::ELitLens,iEncoding->iLitLen);

 	Huffman::Decoding(iEncoding->iDistance,TEncoding::EDistances,iEncoding->iDistance,KDeflateDistCodeBase);

 	}

 TInt CInflater::InflateL()

 //

 // consume all data lag in the history buffer, then decode to fill up the output buffer

 // return the number of available bytes in the output buffer. This is only ever less than

 // the buffer size if the end of stream marker has been read

 //

 	{

 // empty the history buffer into the output

 	TUint8* out=iOut;

 	TUint8* const end=out+KDeflateMaxDistance;

 	const TUint32* tree=iEncoding->iLitLen;

 	if (iLen<0)	// EOF

 		return 0;

 	if (iLen>0)

 		goto useHistory;

 //

 	while (out<end)

 		{

 		// get a huffman code

 		{

 		TInt val=iBits->HuffmanL(tree)-TEncoding::ELiterals;

 		if (val<0)

 			{

 			*out++=TUint8(val);

 			continue;			// another literal/length combo

 			}

 		if (val==TEncoding::EEos-TEncoding::ELiterals)

 			{	// eos marker. we're done

 			iLen=-1;

 			break;

 			}

 		// get the extra bits for the code

 		TInt code=val&0xff;

 		if (code>=8)

 			{	// xtra bits

 			TInt xtra=(code>>2)-1;

 			code-=xtra<<2;

 			code<<=xtra;

 			code|=iBits->ReadL(xtra);

 			}

 		if (val<KDeflateDistCodeBase-TEncoding::ELiterals)

 			{

 			// length code... get the code

 			if(TUint(code)>TUint(KDeflateMaxLength-KDeflateMinLength))

 				{

 				CHECK_FAILURE(KErrCorrupt);

 				goto error;

 				}

 			iLen=code+KDeflateMinLength;

 			tree=iEncoding->iDistance;

 			continue;			// read the huffman code

 			}

 		// distance code

 		if(TUint(code)>TUint(KDeflateMaxDistance-1))

 			{

 			CHECK_FAILURE(KErrCorrupt);

 			goto error;

 			}

 		iRptr=out-(code+1);

 		if (iRptr+KDeflateMaxDistance<end)

 			iRptr+=KDeflateMaxDistance;

 		if(!iLen)

 			{

 			CHECK_FAILURE(KErrCorrupt);

 			goto error;

 			}

 		}

 useHistory:

 		{

 		TInt tfr=Min(end-out,iLen);

 		iLen-=tfr;

 		const TUint8* from=iRptr;

 		do

 			{

 			*out++=*from++;

 			if (from==end)

 				from-=KDeflateMaxDistance;

 			} while (--tfr!=0);

 		iRptr=from;

 		tree=iEncoding->iLitLen;

 		}

 		};

 	return out-iOut;

 error:

 	LEAVE_FAILURE(KErrCorrupt);

 	return 0;

 	}