/*

* Copyright (c) 2003-2010 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 <fntstore.h>

#include <gdi.h>

#include "FNTSTD.H"

#include <graphics/shapeimpl.h>

#include "ShaperCache.H"

#include "openfontsprivate.h"

#include <linkedfonts.h>

#include "linkedfontsprivate.h"

#include <graphics/openfontrasterizer.h>

#include <graphics/gdi/glyphsample.h>

const TInt KSessionCacheEntries = 512;

const TInt KDefaultSlantFactor = 20480;

const TInt KOneIn16Dot16FixedPointFormat = 65536;

template<class T>

ROffsetArray<T>::ROffsetArray()

    : iOffset(0), iCount(0)

    {}

template<class T>

TInt ROffsetArray<T>::Create(RHeap* aHeap, TInt aCount)

    {

    if (iOffset != 0)

        {

        return KErrAlreadyExists;

        }

    TAny* p = aHeap->AllocZ(aCount * sizeof(TInt));

    if (p == NULL)

        {

        return KErrNoMemory;

        }

    iOffset = (TInt)p - (TInt)this;

    iCount = aCount;

    return KErrNone;

    }

template<class T>

void ROffsetArray<T>::Close(RHeap* aHeap)

    {

    if (iOffset != 0)

        {

        aHeap->Free(PtrAdd(this, iOffset));

        }

    iOffset = 0;

    iCount = 0;

    }

template<class T>

TInt ROffsetArray<T>::Count() const

    {

    return iCount;

    }

template<class T>

T* ROffsetArray<T>::operator[](TInt aIndex) const

    {

    TInt e = ((TInt*)PtrAdd(this, iOffset))[aIndex];

    return e != 0 ? (T*)PtrAdd(this, e) : NULL;

    }

template<class T>

void ROffsetArray<T>::SetAt(TInt aIndex, T* aEntry)

    {

    ((TInt*)PtrAdd(this, iOffset))[aIndex] = aEntry ? (TInt)aEntry - (TInt)this : 0;

    }

/*COpenFontGlyphCache*/

TShapeHeader* COpenFontGlyphCache::SearchShaperCache(TInt aSessionHandle, TFontShapeFunctionParameters*& aParams)

	{

	if (iShaperCacheSentinel == NULL)

		return NULL;

	COpenFontShaperCacheEntry* searchNode = iShaperCacheSentinel->iNext;

	TInt start = aParams->iStart;

	TInt end = aParams->iEnd;

	TInt script = aParams->iScript;

	const TUint16* text = (TUint16*)aParams->iText->Ptr();

	TUint16* cachedText;

	const TUint16* copyOfText;

	TInt noOfChars = end - start;

	TInt textIsSame = 1;

	while (searchNode != iShaperCacheSentinel)

		{

		//Future work: add Script check for further script support

		//Future work: add Language check for further language support

		if ((searchNode->iEnd == end) && (searchNode->iStart == start) && (searchNode->iScript == script))

			{

			// Check for the entire text (within the context) coming in.

			TInt i = 0;

			copyOfText = text + start;

			cachedText = (TUint16*)searchNode->iText + searchNode->iStart;

			textIsSame = 1;

			while (i < noOfChars && textIsSame != 0)

				{

				if (*cachedText != *copyOfText)

					textIsSame = 0;

				i++;

				copyOfText++;

				cachedText++;

				};

			if (textIsSame)

				{

				if (searchNode == iShaperCacheSentinel->iNext)

					{

					// now we need to update the reference count here for that session

					if (searchNode->IncRefCount(aSessionHandle) != KErrNone)

						return NULL;

					return iShaperCacheSentinel->iNext->iShapeHeader;

					}

				// We have found a node, now put that node to the top of the list as the most recently used node

				searchNode->iPrevious->iNext = searchNode->iNext;

				searchNode->iNext->iPrevious = searchNode->iPrevious;

				searchNode->iNext = iShaperCacheSentinel->iNext;

				iShaperCacheSentinel->iNext->iPrevious = searchNode;

				iShaperCacheSentinel->iNext = searchNode;

				searchNode->iPrevious = iShaperCacheSentinel;

				if (searchNode->IncRefCount(aSessionHandle)!= KErrNone)

					return NULL;

				return searchNode->iShapeHeader;

				}

			}

			searchNode = searchNode->iNext;

		}

	return NULL;

	}

TShapeHeader* COpenFontGlyphCache::Insert(TInt aSessionHandle, RHeap* aHeap, CShaper::TInput aInput, TShapeHeader* aShapeHeader, TInt& aAddedBytes)

	{

	TInt heapSizeBefAloc = 0;

	aHeap->AllocSize(heapSizeBefAloc);

	COpenFontShaperCacheEntry* new_entry;

	new_entry = COpenFontShaperCacheEntry::New(aHeap, aInput, aShapeHeader);

	if (new_entry != NULL)

		{

		// increase the reference count for this

		TInt ret=new_entry->IncRefCount(aSessionHandle);

		if (ret != KErrNone)

			{

			//no memory here

			COpenFontShaperCacheEntry::Delete(aHeap, new_entry);

			return NULL;

			}

		new_entry->iNext = iShaperCacheSentinel->iNext;

		iShaperCacheSentinel->iNext->iPrevious = new_entry;

		iShaperCacheSentinel->iNext = new_entry;

		new_entry->iPrevious = iShaperCacheSentinel;

		iNumberOfShaperCacheEntries++;

		TInt heapSizeOnAloc = 0;

		aHeap->AllocSize(heapSizeOnAloc);

		aAddedBytes = heapSizeOnAloc - heapSizeBefAloc;

		// Update the amount of memory used in creation of a new entry

		iShapingInfoCacheMemory += heapSizeOnAloc - heapSizeBefAloc;

		return new_entry->iShapeHeader;

		}

	return NULL;

	}

/**

Searches from the least recently used towards the most recently used

and try to free entry that is no longer referenced

*/

TInt COpenFontGlyphCache::DeleteLeastRecentlyUsedEntry(RHeap* aHeap)

	{

	// start from the least recently used

	COpenFontShaperCacheEntry* deleteNode = iShaperCacheSentinel->iPrevious;

	// if empty list there is nothing to delete

	if (deleteNode == iShaperCacheSentinel)

		return 0;

	// else navigating starting from the LRU entry

	while (deleteNode != iShaperCacheSentinel)

		{

		// cannot delete if the iHandleRefCount is greater than zero

		if (deleteNode->iHandleRefCount>0)

			{

			deleteNode = deleteNode->iPrevious;

			continue;

			}

		// otherwise we can delete the entry

		deleteNode->iPrevious->iNext = deleteNode->iNext;

		deleteNode->iNext->iPrevious = deleteNode->iPrevious;

		TInt heapSizeBeforeDel = 0;

		TInt heapSizeAfterDel = 0;

		aHeap->AllocSize(heapSizeBeforeDel);

		COpenFontShaperCacheEntry::Delete(aHeap, deleteNode);

		aHeap->AllocSize(heapSizeAfterDel);

		TInt deletedBytes = heapSizeBeforeDel - heapSizeAfterDel;

		iNumberOfShaperCacheEntries--;

		iShapingInfoCacheMemory -= deletedBytes;

		return deletedBytes;

		}

	// we have navigated through the whole list and cannot delete anything

	return 0;

	}

TInt COpenFont::DecrementCachedRefCount(TInt aSessionHandle, TShapeHeader* aShapeHeader, TBool aResetAll)

	{

	COpenFontShaperCacheEntry* ptr=NULL;

	COpenFontGlyphCache* glyphCache=GetGlyphCache();

	if (glyphCache != NULL)

		ptr=glyphCache->iShaperCacheSentinel;

	if (ptr == NULL)

		return KErrNone;

	TInt ret = KErrNotFound;

	CFontStore* thisFontStore = File()->GetFontStore();

	TInt allocBefDec = 0;

	TInt allocAfterDec = 0;

	TInt deletedBytes = 0;

	// loop through the cache entry to decrement the ref count for a particular session	

	while (ptr->iNext != NULL)

		{

		if (aResetAll)

			{

			// we want to reset any cache that has a matching the session handle

			// i.e. here we dont care about which TShapeHeader and hence we can

			// ignore the error code here if not found

			// Always update the memory usage of the cache as decreasing the ref count 

			// releases memory

			iHeap->AllocSize(allocBefDec);

			ptr->DecRefCount(aSessionHandle, ETrue);

			iHeap->AllocSize(allocAfterDec);

			deletedBytes = allocBefDec - allocAfterDec;

			glyphCache->iShapingInfoCacheMemory -= deletedBytes;

			thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() - deletedBytes);

			ret=KErrNone;

			}

		else if (ptr->iShapeHeader != NULL && ptr->iShapeHeader==aShapeHeader)

			{

			// Always update the memory usage of the cache as decreasing the ref count 

			// releases memory

			iHeap->AllocSize(allocBefDec);

			ptr->DecRefCount(aSessionHandle);

			iHeap->AllocSize(allocAfterDec);

			deletedBytes = allocBefDec - allocAfterDec;

			glyphCache->iShapingInfoCacheMemory -= deletedBytes;

			thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() - deletedBytes);

			return KErrNone;

			}

		ptr=ptr->iNext;

		if (ptr == glyphCache->iShaperCacheSentinel)

			{

			break;

			}

		}

	return ret;

	}

TInt COpenFont::FreeShaperCacheMemory(TInt aBytesNeeded)

	{

	TInt totalDeletedBytes = 0;

	TInt tempDeletedBytes = 0;

	CFontStore* thisFontStore = File()->GetFontStore();

	if (aBytesNeeded <= KMaxShaperSesssionCacheMemory)

		{

		// delete LRU entries from all the caches except the one owned by this COpenFont

		// The 'if' condition here is to avoid looping through every font in the system

		// if only one of the them has a non-empty cache. In situations where only one

		// cache is left and it is full, this strategy makes freeing the memory faster.

		if (thisFontStore->GetNumShaperCaches() > 1)

			{

			CArrayPtrFlat<COpenFont>* fontList;

			CArrayPtrFlat<COpenFontFile>* fontFileList = thisFontStore->GetOpenFontFileList();

			TInt numberOfFontFiles = fontFileList->Count();

			TInt i = 0; 

			while ((totalDeletedBytes < aBytesNeeded) && (i < numberOfFontFiles))

				{

				fontList = (*fontFileList)[i]->GetOpenFontList();

				TInt fontListCount=fontList->Count();

				TInt j = 0;

				while ((totalDeletedBytes < aBytesNeeded) && (j < fontListCount))

					{

					COpenFont* open_font = (*fontList)[j];

					COpenFontGlyphCache* glyphCache = open_font->GetGlyphCache();

					if ((open_font != this) && (glyphCache != NULL))

						{

						while ((totalDeletedBytes < aBytesNeeded) && (!glyphCache->ShaperCacheIsEmpty()))

							{

							totalDeletedBytes += glyphCache->DeleteLeastRecentlyUsedEntry(iHeap);

							if (glyphCache->ShaperCacheIsEmpty())

								{

								thisFontStore->DecNumShaperCaches();

								}

							// If totalDeletedBytes is zero mean we cannot delete from this font

							if (totalDeletedBytes == 0)

								{

								break;

								}

							}

						}

					j++;

					}

				i++;

                }

            }

        // If deleted bytes are still less than the required one delete from this font

        COpenFontGlyphCache* glyphCache = GetGlyphCache();

        if (glyphCache != NULL)

            {

            while (totalDeletedBytes < aBytesNeeded && !glyphCache->ShaperCacheIsEmpty())

                {

                tempDeletedBytes = glyphCache->DeleteLeastRecentlyUsedEntry(iHeap);

                if (tempDeletedBytes == 0)

                    break;

                totalDeletedBytes += tempDeletedBytes;

                }

            }   //if(glyphCache)

        }   //if(aBytesNeeded <= KMaxShaperSesssionCacheMemory)

	// Update the global CFontStore cache memory count

	if (totalDeletedBytes > 0)

		{

		thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() - totalDeletedBytes);

		}

	return totalDeletedBytes;

	}

TShapeHeader* COpenFont::InsertShapedDataIntoCache(TInt aSessionHandle,TFontShapeFunctionParameters* aParams, TShapeHeader* aShapeHeader)

	{

	CShaper::TInput input;

	input.iEnd = aParams->iEnd;

	input.iStart = aParams->iStart;

	input.iScript = aParams->iScript;

	input.iLanguage = aParams->iLanguage;

	input.iText = aParams->iText;

	input.iMaximumAdvance = KMaxTInt;

	input.iFlags = 0;

	input.iSessionHandle = aSessionHandle;

	input.iReserved1 = 0;

	CFontStore* thisFontStore = File()->GetFontStore();

	// Create the glyph cache if it doesn't already exist.

    // This call can only come from FBSERV

    COpenFontGlyphCache* glyphCache = GetGlyphCache();

    if (glyphCache == NULL)

        {

        glyphCache = (COpenFontGlyphCache*) iHeap->Alloc(sizeof(COpenFontGlyphCache));

        if (glyphCache == NULL) // no memory

            {

            return NULL;

            }

        new (glyphCache) COpenFontGlyphCache(iHeap);

        SetGlyphCache(glyphCache);

        }

    // If there is no sentinel present, i.e. new cache

    if (glyphCache->iShaperCacheSentinel == NULL)

        {

        // Create a sentinel

        glyphCache->iShaperCacheSentinel = COpenFontShaperCacheEntry::New(iHeap);

        if (glyphCache->iShaperCacheSentinel == NULL)

            {

            // no memory

            return NULL;

            }

        glyphCache->iShaperCacheSentinel->iNext = glyphCache->iShaperCacheSentinel;

        glyphCache->iShaperCacheSentinel->iPrevious = glyphCache->iShaperCacheSentinel;

        glyphCache->iNumberOfShaperCacheEntries = 1;

        }

    // Before inserting into this cache, check if it was empty.

    // If empty, then increment the global cache count signifying one more cache is active

    if (glyphCache->ShaperCacheIsEmpty())

        {

        thisFontStore->IncNumShaperCaches();

        }

	TInt addedBytes = 0;

	TShapeHeader* cached_header = NULL;

	// Insert a new entry and return the newly inserted TShapeHeader entry

	cached_header = glyphCache->Insert(aSessionHandle, iHeap, input, aShapeHeader, addedBytes);

	if (cached_header == NULL)

		return NULL;

	// If the memory used by all the caches is greater than KMaxShaperSesssionCacheMemory, then

	// free some memory by releasing the same amount of memory that was just added

	if (thisFontStore->GetShaperCacheMemUsage() + addedBytes > KMaxShaperSesssionCacheMemory)

		{

		FreeShaperCacheMemory(addedBytes);

		}

	// Now update the memory count with the added memory for the new entry

	thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() + addedBytes);

	return cached_header;

	}

TShapeHeader* COpenFont::GetShapedData(TInt aSessionHandle, TFontShapeFunctionParameters* aParams)

	{

    COpenFontGlyphCache* glyphCache = GetGlyphCache();

	if (glyphCache == NULL)

		return NULL;

	TShapeHeader* cachedHeader = NULL;

	CFontStore* thisFontStore = File()->GetFontStore();

	// Always update the memory usage of the cache as increasing the reference count of a found header uses up memory

	TInt allocBefInc = 0;

	TInt allocAfterInc = 0;

	iHeap->AllocSize(allocBefInc);

	cachedHeader = glyphCache->SearchShaperCache(aSessionHandle,aParams);

	iHeap->AllocSize(allocAfterInc);

	TInt addedBytes = allocAfterInc - allocBefInc;

	glyphCache->iShapingInfoCacheMemory += addedBytes;

	thisFontStore->SetShaperCacheMemUsage(thisFontStore->GetShaperCacheMemUsage() + addedBytes);

	return cachedHeader;

	}

TBool COpenFontGlyphCache::ShaperCacheIsEmpty()

	{

	if (iShaperCacheSentinel == NULL)

		return ETrue;

	if (iShaperCacheSentinel->iNext == iShaperCacheSentinel)

		return ETrue;

	else

		return EFalse;

	}

/**

C++ constructor taking shared heap, session cache list and font file as parameters.

You must either use this, or the other constructor, when creating your derived 

object. This constructor might be used, in preference to the other, if there 

is only a single typeface in the font file.

@param aHeap The shared heap. 

@param aSessionCacheList The session cache list.

@param aFile A pointer to the COpenFontFile object creating this COpenFont. 

e.g. when creating a COpenFont the COpenFontFile derived object would pass 

it this.

*/

EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

							  COpenFontFile* aFile):

	iHeap(aHeap),

	iShaper(NULL),

	iFaceIndex(0)

	{	

    SetFile(aFile);

    SetSessionCacheList(aSessionCacheList);

	}

/**

C++ constructor taking shared heap, session cache list, font file and face 

index as parameters.

You must either use this, or the other constructor, when creating your derived 

object. This constructor would be used if the font file contains more than 

one typeface.

@param aHeap The shared heap.

@param aSessionCacheList The session cache list.

@param aFile A pointer to the COpenFontFile object creating this COpenFont. 

e.g. when creating a COpenFont the COpenFontFile derived object would pass 

it this.

@param aFaceIndex The index of the typeface within the font file aFile.

*/

EXPORT_C COpenFont::COpenFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList, COpenFontFile* aFile,TInt aFaceIndex) :

 	iHeap(aHeap),

	iShaper(NULL),

	iFaceIndex(aFaceIndex)

	{

    SetFile(aFile);

    SetSessionCacheList(aSessionCacheList);

	}

/**

Destructor

This function frees all memory owned by the object, including the session 

cache list and the glyph list, prior to its destruction.