// Copyright (c) 2009-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 "glyphatlas.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "glyphatlasTraces.h"

#endif

extern void Panic(TFbsPanic aPanic);

static TInt16 Load16(const TUint8* aPtr);

static void DecodeBinaryData(const TSize& aGlyphSize, const TUint8* aEncodedData, TUint8* aByteData);

static void DecodeBinaryDataExLarge(const TSize& aGlyphSize, const TUint8* aEncodedData, TUint8* aByteData);

static void Convert1BppTo8Bpp(TUint32 aSrcData, TUint8*& aDestDataPtr, const TUint8* aDestDataPtrLimit);

static void CopyCharLine(TUint8*& aByteDataPtr, TInt aWidthInBytes, const TUint8* aSrcData, TInt aBitShift, TInt16 aRepeatCount);

// === CGlyphAtlas Functions ===

/**

Glyph Atlas constructor.

@param aMaxCacheSizeInBytes The maximum amount of specialised graphics memory 

	that the glyph atlas should use. If this value is KGlyphAtlasNoCacheLimit,

	then there is no limit and the atlas will use as much memory as is available

	in the system.

*/

CGlyphAtlas::CGlyphAtlas(TInt aMaxCacheSizeInBytes)

	:iLruPageList(_FOFF(CGlyphAtlasPage, iLink)),

	 iFontEntryArray(32, _FOFF(TFontEntryMap, iFont)),

	 iMaxCacheSizeInBytes(aMaxCacheSizeInBytes),

	 iMaxCacheSizeHigh(aMaxCacheSizeInBytes),

	 iGpuCacheSizeLimitIsMax(ETrue)

	{

    iMaxCacheSizeLow = ( KGlyphAtlasNoCacheLimit == aMaxCacheSizeInBytes )

                     ? KGlyphAtlasLowMemCacheLimitDefault

                     : ( aMaxCacheSizeInBytes / KGlyphAtlasLowMemCacheLimitDivisor );

	}

/**

Glyph Atlas destructor.

Frees all the RSgImage handles, frees all the allocated system memory, and

closes the Graphics Resource driver. 

*/

CGlyphAtlas::~CGlyphAtlas()

	{

	// cycle through all the font entries and destroy them

	for (TInt ii = iFontEntryArray.Count()-1; ii >= 0; --ii)

		{

		DeleteFontEntry(iFontEntryArray[ii].iEntry);

		}

	iFontEntryArray.Close();

	__ASSERT_DEBUG(iLruPageList.IsEmpty(), Panic(EFbsPanicGlyphAtlasInconsistentState));

	// there shouldn't be any remaining pages, but if there are, destroy them.

	while (!iLruPageList.IsEmpty())

		{

		delete iLruPageList.First();

		}

	iSgDriver.Close();

	}

/**

Factory constructor method. Creates a new glyph atlas.

@param aMaxCacheSizeInBytes The size in bytes, to use as the upper limit

	for the size of memory used by the glyph images in the atlas. If this

	value is KGlyphAtlasNoCacheLimit, then there is no limit and the atlas

	will use as much memory as is available in the system.

@return A pointer to the newly-constructed atlas

@leave KErrNoMemory if there was insufficient memory to create the atlas, 

	or a system wide error code if its RSgDriver failed to open.

*/

CGlyphAtlas* CGlyphAtlas::NewL(TInt aMaxCacheSizeInBytes)

	{

	CGlyphAtlas* self = new (ELeave) CGlyphAtlas(aMaxCacheSizeInBytes);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); // self;

	return self;

	}

/**

Two-phase constructor.

@leave A system wide error code if RSgDriver failed to open.

*/

void CGlyphAtlas::ConstructL()

	{

	User::LeaveIfError(iSgDriver.Open());

	}

/**

Retrieves a glyph from the atlas.

If the glyph is found, the glyph data passed in is populated.

@param[in] aFont The font the glyph belongs to.

@param[in] aGlyphCode The glyph code for the glyph being requested.

@param[out] aGlyphImageInfo The glyph image information if this function is successful.

@return KErrNone if the glyph is found, KErrNotFound if not. 

*/

TInt CGlyphAtlas::GetGlyph(const CBitmapFont& aFont, TUint aGlyphCode, TGlyphImageInfo& aGlyphImageInfo)

	{

    OstTraceExt2( TRACE_NORMAL, CGLYPHATLAS_GETGLYPH, "> f=%x; gc=%04x",(TUint)&aFont, aGlyphCode);

	CGlyphAtlasFontEntry* fontEntry = FindFontEntry(aFont);

	if (!fontEntry)

		{

        OstTrace0( TRACE_NORMAL, CGLYPHATLAS_GETGLYPH_END2, "< KErrNotFound");

		return KErrNotFound;

		}

	TInt err = fontEntry->GetGlyph(aGlyphCode, aGlyphImageInfo);

	OstTraceExt5( TRACE_NORMAL, CGLYPHATLAS_GETGLYPH_END1, "< id=%08x%08x; w=%u; h=%u; err=%d", 

	        (TUint)I64HIGH(aGlyphImageInfo.iImageId.iId), (TUint)I64LOW(aGlyphImageInfo.iImageId.iId),

	        (TUint)aGlyphImageInfo.iMetrics.Width(), (TUint)aGlyphImageInfo.iMetrics.Height(), (TInt)err);

	return err;

	}

/**

Adds a glyph to the atlas from a bitmap glyph and retrieves the glyph data.

If there is insufficient memory to create a RSgImage, then the least recently 

used pages (and all the glyphs contained within) are removed until there is 

enough memory to continue.

@param[in] aFont The font the glyph belongs to.

@param[in] aArgs The information needed to create a glyph.

@param[out] aGlyphImageInfo Upon return contains all the glyph image information needed to use the 

		glyph in another process.

@return KErrNone if the glyph was successfully added or other system-wide error.

*/

TInt CGlyphAtlas::AddGlyph(const CBitmapFont& aFont, const TAddGlyphArgs& aArgs, TGlyphImageInfo& aGlyphImageInfo)

	{

	OstTraceDefExt5( OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_ADDGLYPH, "> f=%x; bp=%08x; gc=%04x; w=%u; h=%u", 

	        (TUint)&aFont, (TUint)aArgs.iBitmapPointer, aArgs.iGlyphCode, 

	        aArgs.iMetrics->Width(), aArgs.iMetrics->Height());

    // Find font entry and create if none found

	CGlyphAtlasFontEntry* fontEntry = FindFontEntry(aFont);

	TBool isNewFont = EFalse;

	if (!fontEntry)

		{

		// Create a new font.

		fontEntry = CreateFontEntry(aFont);

		if (!fontEntry)

			{

            OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_ADDGLYPH_END2, "< KErrNoMemory");

			return KErrNoMemory;

			}

		isNewFont = ETrue;

		}

	TInt glyphSizeInBytes = 0;

	TInt err = fontEntry->AddGlyph(aArgs, aGlyphImageInfo, glyphSizeInBytes);

	if (KErrNone != err)

		{

		if (isNewFont)

			{

			DeleteFontEntry(fontEntry);

			}

		OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_ADDGLYPH_END3, "< err=%d", err);

		return err;

		}

	iCacheSizeInBytes += glyphSizeInBytes;

	// If there is a cache limit and it is now exceeded, remove the least

	// recently used pages until the cache size is within the upper limit. Do 

	// not remove the page relating to the glyph which is being added, which is 

	// now at the head of the LRU array.

	if (iMaxCacheSizeInBytes != KGlyphAtlasNoCacheLimit)

		{

		TBool morePagesToDelete = ETrue;

		while ((iCacheSizeInBytes > iMaxCacheSizeInBytes) && morePagesToDelete)

			{

			morePagesToDelete = DeleteLeastRecentlyUsedPage(EFalse);

			}

		}

	OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_ADDGLYPH_END1, "< id=%08x%08x", 

	            I64HIGH(aGlyphImageInfo.iImageId.iId), I64LOW(aGlyphImageInfo.iImageId.iId));

	return KErrNone;

	}

/**

Releases all glyphs associated with a particular font when it has been

released by the font system.

@param aFont The font which is released.

 */

void CGlyphAtlas::FontReleased(const CBitmapFont& aFont)

	{

	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_FONTRELEASED, "> f=%x", (TUint)&aFont);

    TInt index = iFontEntryArray.FindInUnsignedKeyOrder(TFontEntryMap(&aFont, NULL));

	if (KErrNotFound == index)

		{

        OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_FONTRELEASED_END2, "< KErrNotFound");

		return;

		}

	CGlyphAtlasFontEntry* fontEntry = iFontEntryArray[index].iEntry;

	iCacheSizeInBytes -= fontEntry->SizeInBytes();

	delete fontEntry;

	iFontEntryArray.Remove(index);

	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_FONTRELEASED_END3, "< KErrNone");

	}

/**

Searches the array of font entries to find the entry for the given font.

If the font entry is found, the entry is returned. If not a NULL pointer is 

returned.

@param aFont The font to match an entry with.

@return The font entry if a match is found, NULL if not. 

*/

CGlyphAtlasFontEntry* CGlyphAtlas::FindFontEntry(const CBitmapFont& aFont) const

	{

	TFontEntryMap entryToMatch(&aFont, NULL);

	TInt index = iFontEntryArray.FindInUnsignedKeyOrder(entryToMatch);

	if (KErrNotFound == index)

		{

		return NULL;

		}

	return iFontEntryArray[index].iEntry;

	}

/**

Deletes the given font entry.

The mapping from the font to the font entry is removed.

@param aFontEntry The entry to delete.

*/

void CGlyphAtlas::DeleteFontEntry(CGlyphAtlasFontEntry* aFontEntry)

	{

    __ASSERT_DEBUG(aFontEntry, Panic(EFbsPanicGlyphAtlasInconsistentState));

    TInt index = iFontEntryArray.FindInUnsignedKeyOrder(TFontEntryMap(&aFontEntry->Font(), NULL));

    __ASSERT_DEBUG(KErrNotFound != index, Panic(EFbsPanicGlyphAtlasInconsistentState));

    if (KErrNotFound != index)

        {

        iFontEntryArray.Remove(index);

        }

    iCacheSizeInBytes -= aFontEntry->SizeInBytes();

    delete aFontEntry;

	}

/**

Moves the given page to the front (the position of the most recently used page) 

of the usage order list.

@param aPage The most recently used page.

*/

void CGlyphAtlas::MovePageToFront(CGlyphAtlasPage& aPage)

	{

	aPage.MoveToFirstInQueue(iLruPageList);

	}

/**

Creates a font entry from the given font and adds a mapping from the font 

to the font entry.

If successful, the font entry is returned.

If either the creation of the font entry or the adding the mapping fails, then 

a NULL pointer is returned.

@param aFont The font used to create a font entry from.

@return A new font entry if successful, NULL if not.

*/

CGlyphAtlasFontEntry* CGlyphAtlas::CreateFontEntry(const CBitmapFont& aFont)

	{

	CGlyphAtlasFontEntry* fontEntry = new CGlyphAtlasFontEntry(aFont, *this);

	if (!fontEntry)

		{

		return NULL;

		}

	// Add font entry to font entry array

	TFontEntryMap fontEntryMap(&aFont, fontEntry);

	TInt err = iFontEntryArray.InsertInUnsignedKeyOrder(fontEntryMap);

	__ASSERT_DEBUG(KErrAlreadyExists != err, Panic(EFbsPanicGlyphAtlasInconsistentState));

	if (KErrNone != err)

		{

		delete fontEntry;

		fontEntry = NULL;

		}

	return fontEntry;

	}

/**

Deletes the least recently used page and removes it from the list of pages

held by the atlas.

@param aAllowMruPageDeletion ETrue if the most recently used page can be deleted, 

	EFalse otherwise.

@return ETrue, if there are pages remaining in the atlas after the deletion, EFalse

	otherwise. If there is only one page in the atlas and aAllowMruPageDeletion is EFalse,

	EFalse is returned. 

*/

TBool CGlyphAtlas::DeleteLeastRecentlyUsedPage(TBool aAllowMruPageDeletion)

	{

    OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_DELETELEASTRECENTLYUSEDPAGE, "> mru=%d", aAllowMruPageDeletion );

	CGlyphAtlasPage* lruPage = NULL;

	if (!iLruPageList.IsEmpty())

		{

		lruPage = iLruPageList.Last();

		if (!aAllowMruPageDeletion && (lruPage == iLruPageList.First()))

			{

			lruPage = NULL;

			}

		}

	TBool canDeleteMorePages = EFalse;

	if (lruPage)

		{

		iCacheSizeInBytes -= lruPage->SizeInBytes();

		CGlyphAtlasFontEntry& fontEntry = lruPage->FontEntry();

		fontEntry.DeletePage(lruPage);

		lruPage = NULL;

		if (fontEntry.IsEmpty())

			{

			DeleteFontEntry(&fontEntry);

			}

		canDeleteMorePages = !iLruPageList.IsEmpty();

		}

	OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_DELETELEASTRECENTLYUSEDPAGE_END, "< more=%u; size=%u", (TUint)canDeleteMorePages, iCacheSizeInBytes);

	return canDeleteMorePages;

	}

/**

Utility function that calculates the number of unique fonts associated with the atlas.

@return Number of fonts in the atlas.

 */

TInt CGlyphAtlas::FontCount() const

	{

	return iFontEntryArray.Count();

	}

/**

Utility function that calculates the number of glyphs across all fonts stored in

the atlas.

@return Number of glyphs in the atlas.

 */

TInt CGlyphAtlas::GlyphCount() const

	{

	TInt glyphCount = 0;

	for (TInt ii = iFontEntryArray.Count() - 1; ii >= 0; --ii)

		{

		glyphCount += iFontEntryArray[ii].iEntry->GlyphCount();

		}

	return glyphCount;

	}

/**

Utility function that calculates the number of glyphs for a given font in the atlas.

@param The font to return the number of glyphs for.

@return Number of glyphs in the atlas.

 */

TInt CGlyphAtlas::GlyphCount(const CBitmapFont& aFont) const

	{

	CGlyphAtlasFontEntry* fontEntry = FindFontEntry(aFont);

	return (fontEntry) ? fontEntry->GlyphCount() : 0;

	}

void CGlyphAtlas::GetGlyphCacheMetrics( TGlyphCacheMetrics& aGlyphCacheMetrics )

    {

    aGlyphCacheMetrics.iMaxCacheSizeInBytes = iMaxCacheSizeInBytes;

    aGlyphCacheMetrics.iMaxCacheSizeHigh = iMaxCacheSizeHigh;

    aGlyphCacheMetrics.iMaxCacheSizeLow = iMaxCacheSizeLow;

    aGlyphCacheMetrics.iCacheSizeInBytes = iCacheSizeInBytes;

    aGlyphCacheMetrics.iGpuCacheSizeLimitIsMax = iGpuCacheSizeLimitIsMax;

    }

/**

 Function to release the GPU cache. Called in response to the GoomMonitor's

 requirement to reduce GPU memory use.

 @param aBytes. The amount of memory the GOoM framework would like us to relinquish.

 @param aFlags. The flags conveyed from the GOoM monitor framework.

*/

void CGlyphAtlas::ReleaseGpuMemory( TInt /*aBytes*/, TInt /*aFlags*/ )

    {

    OstTraceDefExt2( OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_RELEASEGPUMEMORY, "> max=%d; size=%d", iMaxCacheSizeInBytes, iCacheSizeInBytes);

    if ( iCacheSizeInBytes > 0 )

        {

        while( DeleteLeastRecentlyUsedPage(ETrue) )

            {

            // Do nothing

            }

        }

    // If appropriate, reduce the cache-size limit.

    if ( GpuCacheSizeLimitIsMax() )

        {

        SwitchGpuCacheSizeLimit();

        }

    OstTraceDefExt2( OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_RELEASEGPUMEMORY_EXIT, "< max=%d; size=%d", iMaxCacheSizeInBytes, iCacheSizeInBytes);

    }

/**

 Function to establish GPU memory use. Called in response to the GoomMonitor's

 notification that GPU memory may once more be utilised in the usual manner.

 @param aFlags. The flags conveyed from the GOoM monitor framework.

 */

void CGlyphAtlas::InstateGpuMemory( TInt /*aFlags*/ )

    {

    OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_INSTATEGPUMEMORY, "> max=%d", iMaxCacheSizeInBytes );

    // If appropriate, reinstate the full cache-size limit.

    if ( !GpuCacheSizeLimitIsMax() )

        {

        SwitchGpuCacheSizeLimit();

        }

    OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_NORMAL, CGLYPHATLAS_INSTATEGPUMEMORY_EXIT, "< max=%d", iMaxCacheSizeInBytes );

    }

/**

 Utility function to toggle between full and reduced GPU cache-size limits.

 Use in conjunction with TBool GpuCacheSizeLimitIsMax()

 */

void CGlyphAtlas::SwitchGpuCacheSizeLimit()

    {

    if ( GpuCacheSizeLimitIsMax() )

        {

        // The short-circuit operator obviates tautological conditionals.

        while ( (iCacheSizeInBytes >= iMaxCacheSizeLow) && DeleteLeastRecentlyUsedPage(ETrue) )

            {

            // Do Nothing...

            }

        iMaxCacheSizeInBytes = iMaxCacheSizeLow;

        iGpuCacheSizeLimitIsMax = EFalse;

        }

    else

        {

        iMaxCacheSizeInBytes = iMaxCacheSizeHigh;

        iGpuCacheSizeLimitIsMax = ETrue;

        }

    }

/**

 Utility function to report whether the GPU cache-size limit is set to the maximum permissible

 level, or to its reduced level.

 @return ETrue if the cache-size is set to the maximum permissible limit.

         EFalse if it is set to the reduced limit.

 */

TBool CGlyphAtlas::GpuCacheSizeLimitIsMax() const

    {

    return iGpuCacheSizeLimitIsMax;

    }

// === CGlyphAtlasFontEntry Functions ===

/**

Font entry constructor.

@param aFont The font to which this font entry should be associated.

@param aGlyphAtlas The glyph atlas to which this font entry belongs.

*/

CGlyphAtlasFontEntry::CGlyphAtlasFontEntry(const CBitmapFont& aFont, CGlyphAtlas& aGlyphAtlas)

	:iFont(aFont),

	 iPageArray(32, _FOFF(TPageMap, iGlyphCode)),

	 iAtlas(aGlyphAtlas)

	{

	}

/**

Font entry destructor.

Destroys the pages owned by the font entry.

*/

CGlyphAtlasFontEntry::~CGlyphAtlasFontEntry()

	{

	// cycle through all the font entries and destroy them

	for (TInt ii = iPageArray.Count()-1; ii >= 0; --ii)

		{

		DeletePage(iPageArray[ii].iPage);

		}

	__ASSERT_DEBUG(iSizeInBytes == 0, Panic(EFbsPanicGlyphAtlasInconsistentState));

	iPageArray.Close();

	}

/**

Deletes the given page.

The page mapping is removed and the page is deleted.

@param aPage The page to delete.

*/

void CGlyphAtlasFontEntry::DeletePage(CGlyphAtlasPage* aPage)

	{

    __ASSERT_DEBUG(aPage, Panic(EFbsPanicGlyphAtlasInconsistentState));

    __ASSERT_DEBUG(iPageArray.Count() > 0, Panic(EFbsPanicGlyphAtlasInconsistentState));

    TInt numGlyphsInPage = aPage->GlyphCount();

    for (TInt ii = 0; ii < numGlyphsInPage; ++ii)

        {

        TInt index = iPageArray.FindInUnsignedKeyOrder(TPageMap(aPage->GlyphCodeAt(ii), NULL));

        __ASSERT_DEBUG(KErrNotFound != index, Panic(EFbsPanicGlyphAtlasInconsistentState));

        if (KErrNotFound != index)

            {

            iPageArray.Remove(index);

            iPageArray.GranularCompress();

            }

        }

    iSizeInBytes -= aPage->SizeInBytes();

    delete aPage;

	}

/**

Adds a glyph to the font from a bitmap glyph and gets the glyph image info back.