// Copyright (c) 1995-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_pgcompr.cpp

 // 

 //

 #include <f32file.h>

 #include "sf_std.h"

 #include "sf_ldr.h"

 #include <f32image.h>

 #include "sf_image.h"

 #include <e32uid.h>

 #include <e32rom.h>

 #include "sf_cache.h"

 #include "sf_pgcompr.h"

 extern TInt BytePairDecompress(TUint8* /*dst*/, TInt /*dstSize*/, TUint8* /*src*/, TInt /*srcSize*/, TUint8*& /*srcNext*/);

 // CBytePairReader - reading from in-memory buffer

 CBytePairReader* CBytePairReader::NewLC(TUint8* aBuffer, TUint32 aLength)

 	{

 	CBytePairReader* reader = new (ELeave) CBytePairReader(aBuffer, aLength);

 	CleanupStack::PushL(reader);

 	return reader;

 	}

 CBytePairReader::CBytePairReader(TUint8* aBuffer, TUint32 aLength)

 	: iNextPage(aBuffer), iBytesLeft(aLength)

 	{

 	}

 void CBytePairReader::SeekForwardL(TUint aBytes)

 	{

 	if (iBytesLeft < aBytes)

 		LEAVE_FAILURE(KErrCorrupt);

 	iNextPage += aBytes;

 	iBytesLeft -= aBytes;

 	}

 void CBytePairReader::ReadInTableL()

 	{

 	if (KIndexTableHeaderSize > iBytesLeft)

 		LEAVE_FAILURE(KErrCorrupt);

 	Mem::Copy(&iHeader, iNextPage, KIndexTableHeaderSize);

 	iNextPage += KIndexTableHeaderSize;

 	iBytesLeft -= KIndexTableHeaderSize;

 	__IF_DEBUG(Printf("numberOfPages:%d", iHeader.iNumberOfPages));

 	TUint size = iHeader.iNumberOfPages * sizeof(TUint16);

 	if (size > iBytesLeft)

 		LEAVE_FAILURE(KErrCorrupt);

 	// coverity[buffer_alloc]

 	iIndexTable = new (ELeave) TUint16[size/sizeof(TUint16)];

 	Mem::Copy(iIndexTable, iNextPage, size);

 	iNextPage += size;

 	iBytesLeft -= size;

 	} 

 void CBytePairReader::ReleaseTable()

 	{

 	delete[] iIndexTable;

 	iIndexTable = NULL;

 	}

 TUint CBytePairReader::GetPageL(TUint aPageNum, TUint8* aTarget, TInt aLength, TMemoryMoveFunction aMemMoveFn)

 	{

 	if (iIndexTable[aPageNum] > iBytesLeft)

 		LEAVE_FAILURE(KErrCorrupt);

 	iBytesLeft -= iIndexTable[aPageNum];

 	aLength = Min(aLength, KBytePairPageSize);

 	TInt size;

 	TUint8* nextPage;

 	if (aMemMoveFn)

 		size = BytePairDecompress(iPageBuf, aLength, iNextPage, iIndexTable[aPageNum], nextPage);

 	else

 		size = BytePairDecompress(aTarget, aLength, iNextPage, iIndexTable[aPageNum], nextPage);

 	User::LeaveIfError(size);

 	if (size != aLength)

 		LEAVE_FAILURE(KErrCorrupt);

 	if (iNextPage + iIndexTable[aPageNum] != nextPage)

 		LEAVE_FAILURE(KErrCorrupt);

 	// If a memmove() was provided, use that to copy the data to its final target

 	if (aMemMoveFn)

 		aMemMoveFn(aTarget, iPageBuf, size);

 	iNextPage = nextPage;

 	return size;

 	}

 TUint CBytePairReader::DecompressPagesL(TUint8* aTarget, TInt aLength, TMemoryMoveFunction aMemMoveFn)

 	{

 	TUint decompressedSize = 0;

 	ReadInTableL();

 	for (TUint curPage = 0; curPage < iHeader.iNumberOfPages; ++curPage)

 		{

 		TUint size = GetPageL(curPage, aTarget, aLength, aMemMoveFn);

 		decompressedSize += size;

 		aTarget += size;

 		aLength -= size;

 		__IF_DEBUG(Printf("decomp page size:%d\n", size ));

 		} 

 	__IF_DEBUG(Printf("decompressedSize:%d", decompressedSize));

 	ReleaseTable();

 	return decompressedSize;

 	}

 void CBytePairReader::GetPageOffsetsL(TInt32 aInitialOffset, TInt& aPageCount, TInt32*& aPageOffsets)

 	{

 	ReadInTableL();

 	aPageCount = iHeader.iNumberOfPages;

 	aPageOffsets = new (ELeave) TInt32[aPageCount+1];

 	TInt bytes = aInitialOffset + KIndexTableHeaderSize + aPageCount * sizeof(TUint16);

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

 		{

 		aPageOffsets[i] = bytes;

 		bytes += iIndexTable[i];

 		}

 	aPageOffsets[aPageCount] = bytes;

 	ReleaseTable();

 	}

 // CBytePairFileReader - reading from file

 CBytePairFileReader* CBytePairFileReader::NewLC(RFile& aFile)

 	{

 	CBytePairFileReader* reader = new (ELeave) CBytePairFileReader(aFile);

 	CleanupStack::PushL(reader);

 	return reader;

 	}

 CBytePairFileReader::CBytePairFileReader(RFile& aFile)

 	: CBytePairReader(NULL, 0), iFile(aFile)

 	{

 	}	

 CBytePairFileReader::~CBytePairFileReader()

 	{

 	ReleaseTable();

 	}

 void CBytePairFileReader::SeekForwardL(TUint aBytes)

 	{

 	TInt bytes = aBytes;

 	User::LeaveIfError(iFile.Seek(ESeekCurrent, bytes));

 	}

 void CBytePairFileReader::ReadInTableL()

 	{

 	TPtr8 header((TUint8*)&iHeader, KIndexTableHeaderSize);

 	User::LeaveIfError(iFile.Read(header, KIndexTableHeaderSize));

 	if (header.Length() != (TInt)KIndexTableHeaderSize)

 		LEAVE_FAILURE(KErrCorrupt);

 	__IF_DEBUG(Printf("numberOfPages:%d", iHeader.iNumberOfPages));

 	TInt size = iHeader.iNumberOfPages * sizeof(TUint16);

 	iIndexTable = new (ELeave) TUint16[size/sizeof(TUint16)];

 	TPtr8 indexTable((TUint8*)iIndexTable, size);

 	User::LeaveIfError(iFile.Read(indexTable, size));

 	if (indexTable.Length() != size)

 		LEAVE_FAILURE(KErrCorrupt);

 	} 

 TUint CBytePairFileReader::DecompressPagesL(TUint8* aTarget, TInt aLength, TMemoryMoveFunction aMemMoveFn)

 	{

 	TUint decompressedSize = 0;

 	ReadInTableL();

 	TUint curPage = 0;

 	while (curPage < iHeader.iNumberOfPages)

 		{

 		TUint bytes = 0;

 		TUint pages = 0;

 		while (curPage + pages < iHeader.iNumberOfPages &&

 			   bytes + iIndexTable[curPage+pages] < sizeof(iBuffer))

 			{

 			bytes += iIndexTable[curPage+pages];

 			++pages;

 			}

 		if(!bytes)

 			LEAVE_FAILURE(KErrCorrupt);

 		TPtr8 data(iBuffer, bytes);

 		User::LeaveIfError(iFile.Read(data, bytes));

 		if (data.Length() != (TInt)bytes)

 			LEAVE_FAILURE(KErrCorrupt);

 		iNextPage = iBuffer;

 		iBytesLeft = bytes;

 		for (; pages; ++curPage, --pages)

 			{

 			TUint size = GetPageL(curPage, aTarget, aLength, aMemMoveFn);

 			decompressedSize += size;

 			aTarget += size;

 			aLength -= size;

 			__IF_DEBUG(Printf("decomp page size:%d\n", size ));

 			}

 		} 

 	__IF_DEBUG(Printf("decompressedSize:%d", decompressedSize));

 	ReleaseTable();

 	return decompressedSize;

 	}