// 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;
	}