/*
|
* Copyright (C) 2011 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "hwc.h"
|
#include <cutils/list.h>
|
|
#define LAYER_CACHE_SHRINK_NUM 16
|
static struct listnode cacheList;
|
static int cache_cout;
|
static pthread_mutex_t chaceMutex;
|
|
static struct listnode submitCacheList;
|
static int submit_cache_cout;
|
static pthread_mutex_t submitChaceMutex;
|
|
void layerCacheInit(void)
|
{
|
pthread_mutex_init(&chaceMutex, 0);
|
list_init(&cacheList);
|
cache_cout = 0;
|
|
pthread_mutex_init(&submitChaceMutex, 0);
|
list_init(&submitCacheList);
|
submit_cache_cout = 0;
|
}
|
|
void layerCacheDeinit(void)
|
{
|
Layer_t *layer = NULL;
|
LayerSubmit_t *submitLayer = NULL;
|
struct listnode *node = NULL;
|
|
list_for_each(node, &cacheList) {
|
layer = node_to_item(node, Layer_t, node);
|
hwc_free(layer);
|
}
|
list_for_each(node, &submitCacheList) {
|
submitLayer = node_to_item(node, LayerSubmit_t, node);
|
hwc_free(submitLayer);
|
}
|
cache_cout = 0;
|
submit_cache_cout = 0;
|
return;
|
}
|
|
void createList(struct listnode *list) {
|
list_init(list);
|
}
|
|
Layer_t* layerCacheGet(int size)
|
{
|
Layer_t *layer = NULL;
|
struct listnode *node = NULL;
|
|
pthread_mutex_lock(&chaceMutex);
|
if (cache_cout > 0) {
|
cache_cout--;
|
node = list_head(&cacheList);
|
list_remove(node);
|
list_init(node);
|
layer = node_to_item(node, Layer_t, node);
|
}
|
pthread_mutex_unlock(&chaceMutex);
|
if (layer != NULL)
|
goto deal;
|
layer = (Layer_t *)hwc_malloc(sizeof(Layer_t)+ size);
|
if (layer == NULL){
|
ALOGE("%s:malloc layer err...",__FUNCTION__);
|
return NULL;
|
}
|
|
deal:
|
memset(layer, 0, sizeof(Layer_t)+ size);
|
layer->releaseFence = -1;
|
layer->preReleaseFence = -1;
|
layer->acquireFence = -1;
|
layer->myselfHandle = 0;
|
layer->buffer = NULL;
|
layer->ref = 1;
|
list_init(&layer->node);
|
|
return layer;
|
}
|
|
LayerSubmit_t* submitLayerCacheGet(void)
|
{
|
LayerSubmit_t *submitLayer = NULL;
|
struct listnode *node = NULL;
|
|
pthread_mutex_lock(&submitChaceMutex);
|
if (submit_cache_cout > 0) {
|
submit_cache_cout--;
|
node = list_head(&submitCacheList);
|
list_remove(node);
|
list_init(node);
|
submitLayer = node_to_item(node, LayerSubmit_t, node);
|
}
|
pthread_mutex_unlock(&submitChaceMutex);
|
if (submitLayer != NULL)
|
goto deal;
|
|
submitLayer = (LayerSubmit_t *)hwc_malloc(sizeof(LayerSubmit_t));
|
deal:
|
list_init(&submitLayer->node);
|
list_init(&submitLayer->layerNode);
|
submitLayer->sync.fd = -1;
|
submitLayer->sync.count = 0;
|
|
return submitLayer;
|
}
|
|
void incRef(Layer_t *layer)
|
{
|
pthread_mutex_lock(&chaceMutex);
|
layer->ref++;
|
pthread_mutex_unlock(&chaceMutex);
|
}
|
|
void layerCachePut(Layer_t *layer)
|
{
|
private_handle_t *handle;
|
handle = (private_handle_t *)layer->buffer;
|
/* other fd source.if nesesory,
|
* check if close surfaceFlinger's fd
|
*/
|
pthread_mutex_lock(&chaceMutex);
|
layer->ref--;
|
if (layer->ref != 0) {
|
pthread_mutex_unlock(&chaceMutex);
|
return;
|
}
|
pthread_mutex_unlock(&chaceMutex);
|
if (layer->myselfHandle) {
|
if (layer->buffer != NULL && handle->share_fd >= 0)
|
close(handle->share_fd);
|
#if (GRALLOC_SUNXI_METADATA_BUF & (DE_VERSION == 30))
|
if (layer->buffer != NULL && handle->metadata_fd >= 0)
|
close(handle->metadata_fd);
|
#endif
|
layer->myselfHandle = 0;
|
hwc_free((void*)layer->buffer);
|
|
}
|
if (layer->releaseFence >= 0) {
|
close(layer->releaseFence);
|
layer->releaseFence = -1;
|
}
|
if (layer->acquireFence >= 0) {
|
close(layer->acquireFence);
|
layer->acquireFence = -1;
|
}
|
if (layer->preReleaseFence >= 0) {
|
close(layer->preReleaseFence);
|
layer->preReleaseFence = -1;
|
}
|
|
trCachePut(layer->trcache, 1);
|
layer->buffer = NULL;
|
layer->memresrve = 0;
|
layer->trcache = NULL;
|
list_remove(&layer->node);
|
list_init(&layer->node);
|
|
pthread_mutex_lock(&chaceMutex);
|
if (cache_cout > LAYER_CACHE_SHRINK_NUM) {
|
hwc_free(layer);
|
pthread_mutex_unlock(&chaceMutex);
|
return;
|
}
|
|
cache_cout++;
|
list_add_tail(&cacheList, &layer->node);
|
pthread_mutex_unlock(&chaceMutex);
|
|
}
|
|
void submitLayerCachePut(LayerSubmit_t *submitLayer)
|
{
|
Layer_t *layer = NULL;
|
struct listnode *node, *node2;
|
|
list_for_each_safe(node, node2, &submitLayer->layerNode) {
|
layer = node_to_item(node, Layer_t, node);
|
list_remove(&layer->node);
|
list_init(&layer->node);
|
layerCachePut(layer);
|
}
|
if (submitLayer->sync.fd >= 0)
|
close(submitLayer->sync.fd);
|
submitLayer->sync.fd = -1;
|
|
list_remove(&submitLayer->node);
|
list_init(&submitLayer->node);
|
list_init(&submitLayer->layerNode);
|
|
pthread_mutex_lock(&submitChaceMutex);
|
if (submit_cache_cout > LAYER_CACHE_SHRINK_NUM) {
|
hwc_free(submitLayer);
|
pthread_mutex_unlock(&submitChaceMutex);
|
return;
|
}
|
|
submit_cache_cout++;
|
list_add_tail(&submitCacheList, &submitLayer->node);
|
pthread_mutex_unlock(&submitChaceMutex);
|
|
}
|
|
Layer_t* layerDup(Layer_t *layer, int priveSize)
|
{
|
Layer_t *duplayer = layerCacheGet(priveSize);
|
private_handle_t *handle = NULL, *handle2 = NULL;
|
|
memcpy(duplayer, layer, sizeof(Layer_t)+priveSize);
|
list_init(&duplayer->node);
|
|
if (layer->acquireFence >= 0)
|
duplayer->acquireFence = dup(layer->acquireFence);
|
/* dup the gralloc handle */
|
duplayer->myselfHandle = 0;
|
if (layer->buffer != NULL) {
|
duplayer->myselfHandle = 1;
|
handle2 = (private_handle_t *)hwc_malloc(sizeof(private_handle_t));
|
handle = (private_handle_t *)duplayer->buffer;
|
*handle2= *handle;
|
/* other fd source.if nesesory */
|
handle2->share_fd = dup(handle->share_fd);
|
#if (GRALLOC_SUNXI_METADATA_BUF & (DE_VERSION == 30))
|
handle2->metadata_fd = dup(handle->metadata_fd);
|
#endif
|
duplayer->buffer = (buffer_handle_t)handle2;
|
}
|
duplayer->releaseFence = -1;
|
duplayer->preReleaseFence = -1;
|
duplayer->trcache = (void *)trCacheGet(layer);
|
duplayer->ref = 1;
|
return duplayer;
|
}
|
|
void clearList(struct listnode *list, bool lay)
|
{
|
struct listnode *node;
|
Layer_t *layer;
|
LayerSubmit_t *submitLayer;
|
|
while (!list_empty(list)) {
|
node = list_head(list);
|
list_remove(node);
|
if(lay) {
|
layer = node_to_item(node, Layer_t, node);
|
layerCachePut(layer);
|
}else{
|
submitLayer = node_to_item(node, LayerSubmit_t, node);
|
submitLayerCachePut(submitLayer);
|
}
|
}
|
}
|
|
|
int sizeList(struct listnode *list)
|
{
|
struct listnode *node;
|
int length = 0;
|
|
list_for_each(node, list) {
|
length++;
|
}
|
|
return length;
|
}
|
|
|
bool insertLayerByZorder(Layer_t *element, struct listnode *list)
|
{
|
struct listnode *node;
|
Layer_t *layer;
|
bool addone = 1;
|
|
if (list_empty(list)) {
|
list_add_tail(list, &element->node);
|
return addone;
|
}
|
list_for_each(node, list) {
|
layer = node_to_item(node, Layer_t, node);
|
if(layer == element)
|
addone = 0;
|
}
|
list_remove(&element->node);
|
list_for_each(node, list) {
|
layer = node_to_item(node, Layer_t, node);
|
if (layer->zorder > element->zorder){
|
break;
|
}else if (layer->zorder == element->zorder) {
|
/* when resident layers will reorder, not bug */
|
ALOGV("warning: there is same zoder in layer list.\n");
|
}
|
}
|
list_add_tail(node, &element->node);
|
return addone;
|
}
|
|
bool deletLayerByZorder(Layer_t *element, struct listnode *list)
|
{
|
struct listnode *node;
|
Layer_t *layer;
|
|
list_for_each(node, list) {
|
layer = node_to_item(node, Layer_t, node);
|
if (layer == element){
|
list_remove(&element->node);
|
list_init(&element->node);
|
return true;
|
}
|
}
|
return false;
|
}
|
