/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbServers module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbicondatacache_p.h"

#include "hbdoublelinkedlist_p.h"

#include "hbmemoryutils_p.h"

#ifdef HB_SGIMAGE_ICON

#include <sgresource/sgimage.h>

#include <sgresource/sgresource.h>

#include "hbsgimageiconprocessor_p.h"

#endif

/*!

    @hbserver

    \class HbIconDataCache

    \brief HbIconDataCache provides an implementation for the theme server's icon cache.

    It acts as a central repository for storing the various details

    of all the icons cached in the server. It provides various methods to insert new items,

    remove items as well as find existing cached items in the cache.

    It also has methods to limit the cache size both on Gpu as well as Cpu shared memory.

    Reference count based caching - On performing an Icon look up in the server,

    if the icon is not already cached, the cache item is created and inserted into cache

    and its reference count is incremented.

    If the same icon is requested by another application, the cached instance is returned

    and only the reference count is incremented.

    Similarly, the refrence count is decremented whenever an icon is destroyed.

    LRU policy is used for removal of icons from cache.

    The cache maintains two separate doubly link lists to maintain the order

    of the least recently used icons created in GPU memory as well as those created

    in the shared memory. Whenever, the reference count for a cached item becomes 0,

    it is not deleted from the cache rather; the cached icon instance is appended to the LRU list.

    Consider now that a scenario arrives when the cache has reached its max limit

    and there are some unused icons (i.e. icons with reference count = 0) in the LRU list.

    Suppose at this point there is a new icon caching request.

    In such a scenario, the unused icons, starting with those at the beginning of the LRU lists

    are removed from the cache one after the other, till the new icon can be accommodated.

    Description of data members

    // A list that maintains an ordered collection of least recently used icons in GPU

    // which are not being referred to anymore( i.e icons with reference count = 0)

    HbDLinkList gpuLruList;

    // A list that maintains an ordered collection of least recently used icons in CPU

    // which are not being referred to anymore( i.e icons with reference count = 0)

    HbDLinkList cpuLruList;

    // Consolidated size of the GPU Cache being occupied by Icons

    int currentGpuCacheSize;

    // Consolidated size of the CPU Cache being occupied by Icons

    int currentCpuCacheSize;

    // Consolidated size of all the icons with reference count = 0 in GPU Cache

    int gpuLruListSize;

    // Consolidated size of all the icons with reference count = 0 in CPU Cache

    int cpuLruListSize;

    // Maximum GPU Cache Limit size

    int maxGpuCacheLimit;

    // Maximum CPU Cache Limit size

    int maxCpuCacheLimit;

*/

/*!

    \fn HbIconDataCache::HbIconDataCache()

    Constructor

 */

HbIconDataCache::HbIconDataCache()

        : gpuLruList(&HbIconCacheItem::gpuLink),

        cpuLruList(&HbIconCacheItem::cpuLink),

        currentGpuCacheSize(0),

        currentCpuCacheSize(0),

        gpuLruListSize(0),

        cpuLruListSize(0),

        maxGpuCacheLimit(0),

        maxCpuCacheLimit(0),

        goodMemory(true)

{

    cache = new QHash<HbIconKey, HbIconCacheItem*>();

    //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    addedItemRefCount = 0;

    addedItemMem = 0;

    removedItemMem = 0;

    enableCaching = true;

    cacheHit = 0;

    cacheMiss = 0;

    vectorLruListCount = 0;

    rasterLruListCount = 0;

    remRfCount = 0;

#endif

}

/*!

    \fn HbIconDataCache::~HbIconDataCache()

    Destructor

 */

HbIconDataCache::~HbIconDataCache()

{

    clear();

    delete cache;

}

/*!

    \fn HbIconDataCache::clear()

    Clears the complete cache. Also clears the LRU lists.

 */

void HbIconDataCache::clear()

{

    currentGpuCacheSize = 0;

    currentCpuCacheSize = 0;

    gpuLruListSize = 0;

    cpuLruListSize = 0;

    gpuLruList.removeAll();

    cpuLruList.removeAll();

    GET_MEMORY_MANAGER(HbMemoryManager::SharedMemory)

    QHash<HbIconKey, HbIconCacheItem*>::const_iterator itEnd(cache->constEnd());

    for (QHash<HbIconKey,

            HbIconCacheItem *>::const_iterator iter = cache->constBegin();

            iter != itEnd;

            ++iter) {

        HbIconCacheItem *temp = iter.value();

        if (temp->rasterIconData.type != INVALID_FORMAT) {

            switch (temp->rasterIconData.type) {

            case PIC :

                manager->free(temp->rasterIconData.picData.offset);

                break;

            case NVG :

                manager->free(temp->rasterIconData.nvgData.offset);

                break;

            case OTHER_SUPPORTED_FORMATS :

                manager->free(temp->rasterIconData.pixmapData.offset);

                break;

            case SGIMAGE:

#ifdef HB_SGIMAGE_ICON

                HbSgImageRenderer::removeSgImageFromHash(temp->rasterIconData.sgImageData.id);

#endif

                break;

            default:

                break;

            }

        }

        if (temp->vectorIconData.type != INVALID_FORMAT) {

            switch (temp->vectorIconData.type) {

            case PIC :

                manager->free(temp->vectorIconData.picData.offset);

                break;

            case NVG :

                manager->free(temp->vectorIconData.nvgData.offset);

                break;

            case OTHER_SUPPORTED_FORMATS :

                manager->free(temp->vectorIconData.pixmapData.offset);

                break;

            default:

                break;

            }

        }

        if (temp->blobIconData.type == BLOB) {

            manager->free(temp->blobIconData.blobData.offset);

        }

        delete   iter.value();

    }

    cache->clear();

    //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    addedItemRefCount = 0;

    addedItemMem = 0;

    removedItemMem = 0;

    remRfCount = 0;

    enableCaching = true;

    cacheHit = 0;

    cacheMiss = 0;

    vectorLruListCount = 0;

    rasterLruListCount = 0;

#endif

}

/*!

    \fn HbIconDataCache::getCacheItem()

    Provides a mechanism for finidng whether a cache item is present in the cache.

    If found, returns the cache item and increments the reference count else returns NULL.

    \a key denotes the unique identifier for the cache item that is to be searched in the cache.

 */

HbIconCacheItem *HbIconDataCache::getCacheItem(const HbIconKey &key,

        HbRenderingMode currentRenderingMode,

        bool isMultiIconPiece)

{

    HbIconCacheItem *item = 0;

    if (!cache->contains(key)) {

        return 0;

    }

    // Get the cache item associated with the key

    item = (*cache)[(key)];

//Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    addedItemMem = item->rasterIconDataCost;

    cacheHit++;

#endif

    // If the Icon is present in GPU LRU list, then remove it from the list

    if (((item->gpuLink.next() != 0) || (item->gpuLink.prev() != 0)) ||

            ((item == gpuLruList.front()) && (item == gpuLruList.back()))) {

        gpuLruList.removeNode(item);

        updateGpuLruSize(-item->rasterIconDataCost);

        if (gpuLruListSize < 0) {

            gpuLruListSize = 0;

        }

        //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

        addedItemMem = item->rasterIconDataCost;

        rasterLruListCount--;

        if (rasterLruListCount < 0) {

            rasterLruListCount = 0;

        }

#endif

    }

    // If the Icon does not have GPU shared data and there is enough space to cache

    // the icon in GPU cache now, we go ahead and create GPU shared data

    if ((item->rasterIconData.type == INVALID_FORMAT) &&

            (goodMemory && !isMultiIconPiece)) {

        if (item->vectorIconData.type == NVG) {

            HbIconCacheItemCreator::createCacheItem(*item, key, currentRenderingMode);

            if (item->rasterIconData.type != INVALID_FORMAT) {

                currentGpuCacheSize += item->rasterIconDataCost;

            }

        }

//Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

        addedItemMem = item->rasterIconDataCost;

#endif

    }

    // If the Icon is present in CPU LRU list, then remove it from the list

    if (((item->cpuLink.next() != 0) || (item->cpuLink.prev() != 0)) ||

            ((item == cpuLruList.front()) && (item == cpuLruList.back()))) {

        cpuLruList.removeNode(item);

        if (item->rasterIconData.type == OTHER_SUPPORTED_FORMATS) {

            updateCpuLruSize(-item->rasterIconDataCost);

        } else {

            updateCpuLruSize(-item->vectorIconDataCost);

        }

        if (cpuLruListSize < 0){

            cpuLruListSize = 0;

        }

        //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

        addedItemMem = item->vectorIconDataCost;

        vectorLruListCount--;

        if (vectorLruListCount < 0) {

            vectorLruListCount = 0;

        }

#endif

    }

    // If the Icon does not have CPU data and there is enough space to create

    // the icon in CPU cache now, we go ahead and create CPU shared data

    if ((item->vectorIconData.type == INVALID_FORMAT) &&

            (item->rasterIconData.type == SGIMAGE)) {

        if ((item->vectorIconDataCost < (maxCpuCacheLimit - currentCpuCacheSize))) {

            HbIconCacheItemCreator::createCacheItem(*item, key, currentRenderingMode);

            if (item->vectorIconData.type != INVALID_FORMAT) {

                currentCpuCacheSize += item->vectorIconDataCost;

            }

        }

    }

    item->refCount ++;

    //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    addedItemRefCount = item->refCount;

    qDebug() << "HbIconDataCache::getCacheItem: "

             << "Cache hit in Server-Cache for" << key.filename;

    qDebug() << "HbIconDataCache::getCacheItem: Server RefCount now = " << item->refCount;

#endif

    return item;

}

/*!

    \fn HbIconDataCache::insert()

    Provides a mechanism for inserting items into the cache.

    Checks are first done to see whether item can be accomodated in the GPU memory.

    If so the Gpu limits are updated. Next it tries to cache the item in the Cpu.

    If possible, the Cpu limits are updated. If neither is possible,

    a failure to insert is returned.

    In case of success, the item is inserted into the cache and

    the reference count for the item is incremented by 1.

    \a key denotes the unique identifier for the cache item that is to be inserted into the cache.

    \a item the cache item that is to be inserted into the cache.

 */

bool HbIconDataCache::insert(const HbIconKey &key, HbIconCacheItem *item)

{

    if (!item) {

        return false;

    }

    // Check if Item can be accomdated in GPU cache

    bool gpuCaching = isItemCachableInGpu(item);

    // Check if Item can be accomdated in CPU cache

    bool cpuCaching = isItemCachableInCpu(item);

    // Item cannot be inserted either into GPU cache memory or CPU cache memory

    if ((!gpuCaching) && (!cpuCaching)) {

        return false;

    }

    // Item can be accomdated in GPU cache

    if (gpuCaching) {

        // Increment the GPU cache size

        if( item->rasterIconDataCost <=  maxGpuCacheLimit ) {

            currentGpuCacheSize += item->rasterIconDataCost;

        } 

    }

    // Item can be accomdated in CPU cache

    if (cpuCaching) {

        if (item->rasterIconData.type == OTHER_SUPPORTED_FORMATS) {

            if (item->rasterIconDataCost <= (maxCpuCacheLimit - currentCpuCacheSize)) {

                currentCpuCacheSize += item->rasterIconDataCost;

            } else {

                createCpuCacheSpace(item->rasterIconDataCost);

                currentCpuCacheSize += item->rasterIconDataCost;

            }

        }

        if (item->vectorIconData.type != INVALID_FORMAT) {

            // Increment the CPU cache size

            if (item->vectorIconDataCost <= (maxCpuCacheLimit - currentCpuCacheSize)) {

                currentCpuCacheSize += item->vectorIconDataCost;

            } else {

                // New item's icon data cost is more than available free CPU cahe size

                // Check if some items, whose ref count is 0,

                // can be removed to make way for new item

                createCpuCacheSpace(item->vectorIconDataCost);

                currentCpuCacheSize += item->vectorIconDataCost;

            }

        }

        if (currentCpuCacheSize > maxCpuCacheLimit) {

            currentCpuCacheSize = maxCpuCacheLimit;

        }

    }

    QHash<HbIconKey, HbIconCacheItem*>::iterator iter =

            cache->insert(key, const_cast<HbIconCacheItem*>(item));

    if (iter == cache->end()) {

        return false;

    }

    item->refCount ++;

    //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    cacheMiss++;

    addedItemRefCount = item->refCount;

    if (gpuCaching) {

        addedItemMem = item->rasterIconDataCost;

    } else if (cpuCaching) {

        addedItemMem = item->vectorIconDataCost;

    }

    qDebug() << "HbIconDataCache::insert: " << "Item " << key.filename

             << " inserted in Server-Cache";

    qDebug() << "HbIconDataCache::insert: Server RefCount now = " << item->refCount;

#endif

    return true;

}

/*!

    \fn HbIconDataCache::remove()

    Remove provides a mechanism for decrementing the reference count of a cached item.

    In case the reference count becomes 0,

    the cache item instance is appended to the corresponding LRU list.

    Actual removal of the cache item from the cache only occurs

    when the cache has reached a max limit and a new request for insert comes.

    \a key denotes the unique identifier for the cache item whose

       ref count is to be decremented in the cache.

 */

bool HbIconDataCache::remove(const HbIconKey &key, bool keepInCache)

{

    if (key.filename.isEmpty() || !cache->contains(key)) {

        return false;

    }

    HbIconCacheItem *item = (*cache)[(key)];

    item->refCount--;

    //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

    remRfCount = item->refCount;

#endif

    if (item->refCount == 0) {

        if (item->rasterIconData.type == SGIMAGE) {

                gpuLruList.insertBack(item);

                updateGpuLruSize(item->rasterIconDataCost);

            } else {

                return true;

            }

        }

        if (item->rasterIconData.type == OTHER_SUPPORTED_FORMATS) {

            if (keepInCache) {

                cpuLruList.insertBack(item);

                updateCpuLruSize(item->rasterIconDataCost);

            } else {

                releaseRasterItem(item);

                removeFromCache(key, item);

                return true;

            }

        }

        //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

        if (! enableCaching) {

            currentGpuCacheSize -= item->rasterIconDataCost;

            removedItemMem = item->rasterIconDataCost;

            removeFromCache(key, item);

            rasterLruListCount--;

            if (rasterLruListCount < 0) {

                rasterLruListCount = 0;

            }

            if (currentGpuCacheSize < 0) {

                currentGpuCacheSize = 0;

            }

        } else {

#endif

            //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

            rasterLruListCount++;

        }

#endif

        if ((item->vectorIconData.type != INVALID_FORMAT) &&  item->refCount == 0) {

            //Debug Code for Test Purpose

#ifdef HB_ICON_CACHE_DEBUG

            if (! enableCaching) {

                currentCpuCacheSize -= item->vectorIconDataCost;

                removedItemMem = item->vectorIconDataCost;

                removeFromCache(key, item);

                vectorLruListCount--;

                if (vectorLruListCount < 0) {

                    vectorLruListCount = 0;

                }

                if (currentCpuCacheSize < 0) {

                    currentCpuCacheSize = 0;

                }

            } else {

#endif

                if (keepInCache) {

                    cpuLruList.insertBack(item);

                    updateCpuLruSize(item->vectorIconDataCost);

                } else {

                    releaseVectorItem(item);

                    removeFromCache(key, item);

                    return true;

                }

                //Debug Code for Test Purpose