#include <png.h>
#include <pixman.h>
+#define TBM_SURFACE_MAGIC 0xBF021234
+
static tbm_bufmgr g_surface_bufmgr;
-static pthread_mutex_t tbm_surface_lock;
+static pthread_mutex_t tbm_surface_lock = PTHREAD_MUTEX_INITIALIZER;
void _tbm_surface_mutex_unlock(void);
-#define C(b, m) (((b) >> (m)) & 0xFF)
-#define B(c, s) ((((unsigned int)(c)) & 0xff) << (s))
-#define FOURCC(a, b, c, d) (B(d, 24) | B(c, 16) | B(b, 8) | B(a, 0))
-#define FOURCC_STR(id) C(id, 0), C(id, 8), C(id, 16), C(id, 24)
-#define FOURCC_ID(str) FOURCC(((char*)str)[0], ((char*)str)[1], ((char*)str)[2], ((char*)str)[3])
-
/* check condition */
#define TBM_SURFACE_RETURN_IF_FAIL(cond) {\
if (!(cond)) {\
TBM_ERR("'%s' failed.\n", #cond);\
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
_tbm_surface_mutex_unlock();\
return;\
} \
#define TBM_SURFACE_RETURN_VAL_IF_FAIL(cond, val) {\
if (!(cond)) {\
TBM_ERR("'%s' failed.\n", #cond);\
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);\
_tbm_surface_mutex_unlock();\
return val;\
} \
}
}
-static bool
-_tbm_surface_mutex_init(void)
-{
- static bool tbm_surface_mutex_init = false;
-
- if (tbm_surface_mutex_init)
- return true;
-
- if (pthread_mutex_init(&tbm_surface_lock, NULL)) {
- TBM_ERR("fail: pthread_mutex_init for tbm_surface_lock.\n");
- return false;
- }
-
- tbm_surface_mutex_init = true;
-
- return true;
-}
-
void
_tbm_surface_mutex_lock(void)
{
- if (!_tbm_surface_mutex_init()) {
- TBM_ERR("fail: _tbm_surface_mutex_init.\n");
- return;
- }
-
pthread_mutex_lock(&tbm_surface_lock);
}
/* LCOV_EXCL_STOP */
static int
-_tbm_surface_internal_is_valid(tbm_surface_h surface)
+_tbm_surface_internal_magic_check(tbm_surface_h surface)
{
- tbm_surface_h old_data = NULL;
+ if (surface->magic != TBM_SURFACE_MAGIC)
+ return 0;
- TBM_RETURN_VAL_IF_FAIL(g_surface_bufmgr, 0);
- TBM_RETURN_VAL_IF_FAIL(surface, 0);
+ return 1;
+}
- if (!LIST_IS_EMPTY(&g_surface_bufmgr->surf_list)) {
- LIST_FOR_EACH_ENTRY(old_data, &g_surface_bufmgr->surf_list, item_link) {
- if (old_data == surface) {
- TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p)\n", surface);
- return 1;
- }
- }
+static int
+_tbm_surface_internal_is_valid(tbm_surface_h surface)
+{
+ if (!surface) {
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
+ TBM_ERR("error: No valid tbm_surface is NULL\n");
+ return 0;
}
- TBM_ERR("error: No valid tbm_surface(%p)\n", surface);
+ if (!_tbm_surface_internal_magic_check(surface)) {
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
+ TBM_ERR("error: No valid tbm_surface(%p)\n", surface);
+ return 0;
+ }
- return 0;
+ return 1;
}
static int
TBM_RETURN_VAL_IF_FAIL(surf->info.height > 0, 0);
TBM_RETURN_VAL_IF_FAIL(surf->info.format > 0, 0);
- if (bufmgr->backend_module_data) {
- if (!bufmgr->bufmgr_func->bufmgr_get_plane_data)
+ if (bufmgr->use_hal_tbm) {
+ error = (tbm_error_e)hal_tbm_bufmgr_get_plane_data(bufmgr->hal_bufmgr, (hal_tbm_format)surf->info.format,
+ plane_idx, surf->info.width, surf->info.height, size, offset, pitch, bo_idx);
+ /* LCOV_EXCL_START */
+ if (error == TBM_ERROR_NOT_SUPPORTED) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+ return 0;
+ } else if (error != TBM_ERROR_NONE) {
+ TBM_ERR("Fail to surface_get_plane_data. surface(%p) error(%d)\n", surface, error);
+ _tbm_set_last_result(error);
+ return 0;
+ }
+ /* LCOV_EXCL_STOP */
+ ret = 1;
+ } else if (bufmgr->backend_module_data) {
+ if (!bufmgr->bufmgr_func->bufmgr_get_plane_data) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
return 0;
+ }
error = bufmgr->bufmgr_func->bufmgr_get_plane_data(bufmgr->bufmgr_data, surf->info.format, plane_idx,
surf->info.width, surf->info.height, size, offset, pitch, bo_idx);
if (error != TBM_ERROR_NONE) {
/* LCOV_EXCL_START */
TBM_ERR("Fail to surface_get_plane_data. surface(%p) error(%d)\n", surface, error);
+ _tbm_set_last_result(error);
return 0;
/* LCOV_EXCL_STOP */
}
ret = 1;
} else {
- if (!bufmgr->backend->surface_get_plane_data)
+ if (!bufmgr->backend->surface_get_plane_data) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
return 0;
+ }
ret = bufmgr->backend->surface_get_plane_data(surf->info.width,
surf->info.height, surf->info.format, plane_idx, size, offset, pitch, bo_idx);
if (!ret) {
/* LCOV_EXCL_START */
TBM_ERR("Fail to surface_get_plane_data. surface(%p)\n", surface);
+ _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
return 0;
/* LCOV_EXCL_STOP */
}
}
LIST_DEL(&surface->item_link);
+ surface->magic = 0;
free(surface);
surface = NULL;
- if (LIST_IS_EMPTY(&bufmgr->surf_list)) {
+ if (bufmgr && LIST_IS_EMPTY(&bufmgr->surf_list)) {
LIST_DELINIT(&bufmgr->surf_list);
if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
return num_planes;
}
+static int
+_tbm_surface_internal_get_bpp(tbm_format format)
+{
+
+ int bpp = 0;
+
+ switch (format) {
+ case TBM_FORMAT_C8:
+ case TBM_FORMAT_RGB332:
+ case TBM_FORMAT_BGR233:
+ bpp = 8;
+ break;
+ case TBM_FORMAT_XRGB4444:
+ case TBM_FORMAT_XBGR4444:
+ case TBM_FORMAT_RGBX4444:
+ case TBM_FORMAT_BGRX4444:
+ case TBM_FORMAT_ARGB4444:
+ case TBM_FORMAT_ABGR4444:
+ case TBM_FORMAT_RGBA4444:
+ case TBM_FORMAT_BGRA4444:
+ case TBM_FORMAT_XRGB1555:
+ case TBM_FORMAT_XBGR1555:
+ case TBM_FORMAT_RGBX5551:
+ case TBM_FORMAT_BGRX5551:
+ case TBM_FORMAT_ARGB1555:
+ case TBM_FORMAT_ABGR1555:
+ case TBM_FORMAT_RGBA5551:
+ case TBM_FORMAT_BGRA5551:
+ case TBM_FORMAT_RGB565:
+ case TBM_FORMAT_BGR565:
+ bpp = 16;
+ break;
+ case TBM_FORMAT_RGB888:
+ case TBM_FORMAT_BGR888:
+ bpp = 24;
+ break;
+ case TBM_FORMAT_XRGB8888:
+ case TBM_FORMAT_XBGR8888:
+ case TBM_FORMAT_RGBX8888:
+ case TBM_FORMAT_BGRX8888:
+ case TBM_FORMAT_ARGB8888:
+ case TBM_FORMAT_ABGR8888:
+ case TBM_FORMAT_RGBA8888:
+ case TBM_FORMAT_BGRA8888:
+ case TBM_FORMAT_XRGB2101010:
+ case TBM_FORMAT_XBGR2101010:
+ case TBM_FORMAT_RGBX1010102:
+ case TBM_FORMAT_BGRX1010102:
+ case TBM_FORMAT_ARGB2101010:
+ case TBM_FORMAT_ABGR2101010:
+ case TBM_FORMAT_RGBA1010102:
+ case TBM_FORMAT_BGRA1010102:
+ case TBM_FORMAT_YUYV:
+ case TBM_FORMAT_YVYU:
+ case TBM_FORMAT_UYVY:
+ case TBM_FORMAT_VYUY:
+ case TBM_FORMAT_AYUV:
+ bpp = 32;
+ break;
+ case TBM_FORMAT_NV12:
+ case TBM_FORMAT_NV12MT:
+ case TBM_FORMAT_NV21:
+ bpp = 12;
+ break;
+ case TBM_FORMAT_NV16:
+ case TBM_FORMAT_NV61:
+ bpp = 16;
+ break;
+ case TBM_FORMAT_YUV410:
+ case TBM_FORMAT_YVU410:
+ bpp = 9;
+ break;
+ case TBM_FORMAT_YUV411:
+ case TBM_FORMAT_YVU411:
+ case TBM_FORMAT_YUV420:
+ case TBM_FORMAT_YVU420:
+ bpp = 12;
+ break;
+ case TBM_FORMAT_YUV422:
+ case TBM_FORMAT_YVU422:
+ bpp = 16;
+ break;
+ case TBM_FORMAT_YUV444:
+ case TBM_FORMAT_YVU444:
+ bpp = 24;
+ break;
+ default:
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
+ break;
+ }
+
+ return bpp;
+}
+
int
tbm_surface_internal_is_valid(tbm_surface_h surface)
{
int ret = 0;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
/* Return silently if surface is null. */
if (!surface) {
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
tbm_surface_internal_query_supported_formats(uint32_t **formats,
uint32_t *num)
{
- TBM_RETURN_VAL_IF_FAIL(formats, 0);
- TBM_RETURN_VAL_IF_FAIL(num, 0);
-
struct _tbm_bufmgr *bufmgr;
int ret = 0;
bool bufmgr_initialized = false;
tbm_error_e error;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(formats, 0);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(num, 0);
if (!g_surface_bufmgr) {
_init_surface_bufmgr();
bufmgr = g_surface_bufmgr;
- if (bufmgr->backend_module_data) {
- if (!bufmgr->bufmgr_func->bufmgr_get_supported_formats)
+ if (bufmgr->use_hal_tbm) {
+ error = (tbm_error_e)hal_tbm_bufmgr_get_supported_formats(bufmgr->hal_bufmgr, formats, num);
+ /* LCOV_EXCL_START */
+ if (error == TBM_ERROR_NOT_SUPPORTED) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
+ goto fail;
+ } else if (error != TBM_ERROR_NONE) {
+ _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
+ goto fail;
+ }
+ /* LCOV_EXCL_STOP */
+ ret = 1;
+ } else if (bufmgr->backend_module_data) {
+ if (!bufmgr->bufmgr_func->bufmgr_get_supported_formats) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
goto fail;
+ }
error = bufmgr->bufmgr_func->bufmgr_get_supported_formats(bufmgr->bufmgr_data, formats, num);
if (error != TBM_ERROR_NONE) {
}
ret = 1;
} else {
- if (!bufmgr->backend->surface_supported_format)
+ if (!bufmgr->backend->surface_supported_format) {
+ _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED);
goto fail;
+ }
ret = bufmgr->backend->surface_supported_format(formats, num);
if (!ret) {
/* LCOV_EXCL_START */
TBM_ERR("Fail to surface_supported_format.\n");
+ _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
goto fail;
/* LCOV_EXCL_START */
}
int
tbm_surface_internal_get_bpp(tbm_format format)
{
-
int bpp = 0;
- switch (format) {
- case TBM_FORMAT_C8:
- case TBM_FORMAT_RGB332:
- case TBM_FORMAT_BGR233:
- bpp = 8;
- break;
- case TBM_FORMAT_XRGB4444:
- case TBM_FORMAT_XBGR4444:
- case TBM_FORMAT_RGBX4444:
- case TBM_FORMAT_BGRX4444:
- case TBM_FORMAT_ARGB4444:
- case TBM_FORMAT_ABGR4444:
- case TBM_FORMAT_RGBA4444:
- case TBM_FORMAT_BGRA4444:
- case TBM_FORMAT_XRGB1555:
- case TBM_FORMAT_XBGR1555:
- case TBM_FORMAT_RGBX5551:
- case TBM_FORMAT_BGRX5551:
- case TBM_FORMAT_ARGB1555:
- case TBM_FORMAT_ABGR1555:
- case TBM_FORMAT_RGBA5551:
- case TBM_FORMAT_BGRA5551:
- case TBM_FORMAT_RGB565:
- case TBM_FORMAT_BGR565:
- bpp = 16;
- break;
- case TBM_FORMAT_RGB888:
- case TBM_FORMAT_BGR888:
- bpp = 24;
- break;
- case TBM_FORMAT_XRGB8888:
- case TBM_FORMAT_XBGR8888:
- case TBM_FORMAT_RGBX8888:
- case TBM_FORMAT_BGRX8888:
- case TBM_FORMAT_ARGB8888:
- case TBM_FORMAT_ABGR8888:
- case TBM_FORMAT_RGBA8888:
- case TBM_FORMAT_BGRA8888:
- case TBM_FORMAT_XRGB2101010:
- case TBM_FORMAT_XBGR2101010:
- case TBM_FORMAT_RGBX1010102:
- case TBM_FORMAT_BGRX1010102:
- case TBM_FORMAT_ARGB2101010:
- case TBM_FORMAT_ABGR2101010:
- case TBM_FORMAT_RGBA1010102:
- case TBM_FORMAT_BGRA1010102:
- case TBM_FORMAT_YUYV:
- case TBM_FORMAT_YVYU:
- case TBM_FORMAT_UYVY:
- case TBM_FORMAT_VYUY:
- case TBM_FORMAT_AYUV:
- bpp = 32;
- break;
- case TBM_FORMAT_NV12:
- case TBM_FORMAT_NV12MT:
- case TBM_FORMAT_NV21:
- bpp = 12;
- break;
- case TBM_FORMAT_NV16:
- case TBM_FORMAT_NV61:
- bpp = 16;
- break;
- case TBM_FORMAT_YUV410:
- case TBM_FORMAT_YVU410:
- bpp = 9;
- break;
- case TBM_FORMAT_YUV411:
- case TBM_FORMAT_YVU411:
- case TBM_FORMAT_YUV420:
- case TBM_FORMAT_YVU420:
- bpp = 12;
- break;
- case TBM_FORMAT_YUV422:
- case TBM_FORMAT_YVU422:
- bpp = 16;
- break;
- case TBM_FORMAT_YUV444:
- case TBM_FORMAT_YVU444:
- bpp = 24;
- break;
- default:
- break;
+ _tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ bpp = _tbm_surface_internal_get_bpp(format);
+ if (!bpp) {
+ TBM_ERR("error: tbm_error(%s)\n", tbm_error_str(tbm_get_last_error()));
+ _tbm_surface_mutex_unlock();
+ return 0;
}
+ _tbm_surface_mutex_unlock();
+
TBM_TRACE_SURFACE_INTERNAL("tbm_format(%s) bpp(%d)\n", _tbm_surface_internal_format_to_str(format), bpp);
return bpp;
tbm_surface_internal_create_with_flags(int width, int height,
int format, int flags)
{
- TBM_RETURN_VAL_IF_FAIL(width > 0, NULL);
- TBM_RETURN_VAL_IF_FAIL(height > 0, NULL);
-
struct _tbm_bufmgr *bufmgr;
struct _tbm_surface *surf = NULL;
uint32_t size = 0;
int bo_idx;
int i, j;
bool bufmgr_initialized = false;
- tbm_bo bo = NULL;
- void *bo_priv = NULL;
- tbm_backend_bo_data *bo_data = NULL;
tbm_error_e error;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(width > 0, NULL);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(height > 0, NULL);
if (!g_surface_bufmgr) {
_init_surface_bufmgr();
if (!surf) {
/* LCOV_EXCL_START */
TBM_ERR("fail to alloc surf\n");
+ _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
goto alloc_surf_fail;
/* LCOV_EXCL_STOP */
}
+ surf->magic = TBM_SURFACE_MAGIC;
surf->bufmgr = bufmgr;
surf->info.width = width;
surf->info.height = height;
surf->info.format = format;
- surf->info.bpp = tbm_surface_internal_get_bpp(format);
+ surf->info.bpp = _tbm_surface_internal_get_bpp(format);
+ if (!surf->info.bpp) {
+ TBM_ERR("fail to get bpp. error(%s)\n", tbm_error_str(tbm_get_last_error()));
+ goto bpp_fail;
+ }
surf->info.num_planes = _tbm_surface_internal_get_num_planes(format);
if (!surf->info.num_planes) {
TBM_ERR("fail to get num_planes. error(%s)\n", tbm_error_str(tbm_get_last_error()));
bo_size += surf->info.planes[j].size;
}
- if (bufmgr->backend_module_data) {
+ if (bufmgr->use_hal_tbm) {
+ surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, flags, &error);
+ if (error == TBM_ERROR_NOT_SUPPORTED) {
+ if (flags & TBM_BO_TILED) {
+ surf->bos[i] = tbm_bo_alloc_with_tiled_format(bufmgr, width, height, surf->info.bpp/8, format, flags, i, &error);
+ if (error == TBM_ERROR_NOT_SUPPORTED) {
+ surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
+ } else if (error != TBM_ERROR_NONE) {
+ TBM_ERR("fail to alloc bo idx:%d\n", i);
+ goto alloc_bo_fail;
+ }
+ } else {
+ surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
+ }
+
+ if (!surf->bos[i]) {
+ TBM_ERR("fail to alloc bo idx:%d\n", i);
+ goto alloc_bo_fail;
+ }
+ } else if (error != TBM_ERROR_NONE) {
+ TBM_ERR("fail to alloc bo idx:%d\n", i);
+ goto alloc_bo_fail;
+ }
+ } else if (bufmgr->backend_module_data) {
if (bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) {
/* LCOV_EXCL_START */
- bo = calloc(1, sizeof(struct _tbm_bo));
- if (!bo) {
- TBM_ERR("fail to alloc bo struct\n");
+ surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, flags, &error);
+ if (!surf->bos[i]) {
+ TBM_ERR("fail to tbm_bo_alloc_with_format idx:%d\n", i);
goto alloc_bo_fail;
}
-
- bo->bufmgr = surf->bufmgr;
-
- pthread_mutex_lock(&surf->bufmgr->lock);
-
- bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format(bufmgr->bufmgr_data, format, i,
- width, height, flags, &error);
- if (!bo_data) {
- TBM_ERR("fail to alloc bo priv. error(%d)\n", error);
- free(bo);
- pthread_mutex_unlock(&surf->bufmgr->lock);
+ /* LCOV_EXCL_STOP */
+ } else if (bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format && (flags & TBM_BO_TILED)) {
+ /* LCOV_EXCL_START */
+ surf->bos[i] = tbm_bo_alloc_with_tiled_format(bufmgr, width, height, surf->info.bpp/8, format, flags, i, &error);
+ if (!surf->bos[i]) {
+ TBM_ERR("fail to tbm_bo_alloc_with_tiled_format idx:%d\n", i);
goto alloc_bo_fail;
}
- bo->bo_data = bo_data;
-
- bo->ref_cnt = 1;
- bo->flags = flags;
- LIST_INITHEAD(&bo->user_data_list);
-
- LIST_ADD(&bo->item_link, &surf->bufmgr->bo_list);
-
- pthread_mutex_unlock(&surf->bufmgr->lock);
-
- surf->bos[i] = bo;
/* LCOV_EXCL_STOP */
} else {
surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
} else {
if (bufmgr->backend->surface_bo_alloc) {
/* LCOV_EXCL_START */
- bo = calloc(1, sizeof(struct _tbm_bo));
- if (!bo) {
- TBM_ERR("fail to alloc bo struct\n");
- goto alloc_bo_fail;
- }
-
- bo->bufmgr = surf->bufmgr;
-
- pthread_mutex_lock(&surf->bufmgr->lock);
-
- bo_priv = bufmgr->backend->surface_bo_alloc(bo, width, height, format, flags, i);
- if (!bo_priv) {
- TBM_ERR("fail to alloc bo priv\n");
- free(bo);
- pthread_mutex_unlock(&surf->bufmgr->lock);
+ surf->bos[i] = tbm_bo_alloc_with_surface(bufmgr, width, height, format, flags, i);
+ if (!surf->bos[i]) {
+ TBM_ERR("fail to tbm_bo_alloc_with_surface idx:%d\n", i);
goto alloc_bo_fail;
- }
- bo->priv = bo_priv;
-
- bo->ref_cnt = 1;
- bo->flags = flags;
- LIST_INITHEAD(&bo->user_data_list);
-
- LIST_ADD(&bo->item_link, &surf->bufmgr->bo_list);
-
- pthread_mutex_unlock(&surf->bufmgr->lock);
-
- surf->bos[i] = bo;
/* LCOV_EXCL_STOP */
+ }
} else {
surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
if (!surf->bos[i]) {
tbm_bo_unref(surf->bos[j]);
}
query_plane_data_fail:
+bpp_fail:
num_planes_fail:
free(surf);
alloc_surf_fail:
tbm_surface_internal_create_with_bos(tbm_surface_info_s *info,
tbm_bo *bos, int num)
{
- TBM_RETURN_VAL_IF_FAIL(bos, NULL);
- TBM_RETURN_VAL_IF_FAIL(info, NULL);
- TBM_RETURN_VAL_IF_FAIL(info->num_planes > 0, NULL);
- TBM_RETURN_VAL_IF_FAIL(num > 0, NULL);
- TBM_RETURN_VAL_IF_FAIL(num == 1 || info->num_planes == num, NULL);
-
struct _tbm_bufmgr *bufmgr;
struct _tbm_surface *surf = NULL;
int i;
bool bufmgr_initialized = false;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(bos, NULL);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(info, NULL);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(info->num_planes > 0, NULL);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(num > 0, NULL);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(num == 1 || info->num_planes == num, NULL);
if (!g_surface_bufmgr) {
_init_surface_bufmgr();
bufmgr = g_surface_bufmgr;
if (!TBM_BUFMGR_IS_VALID(bufmgr)) {
TBM_ERR("fail to validate the Bufmgr.\n");
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
goto check_valid_fail;
}
if (!surf) {
/* LCOV_EXCL_START */
TBM_ERR("fail to allocate struct _tbm_surface.\n");
+ _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
goto alloc_surf_fail;
/* LCOV_EXCL_STOP */
}
+ surf->magic = TBM_SURFACE_MAGIC;
surf->bufmgr = bufmgr;
surf->info.width = info->width;
surf->info.height = info->height;
surf->info.format = info->format;
if (info->bpp > 0)
surf->info.bpp = info->bpp;
- else
- surf->info.bpp = tbm_surface_internal_get_bpp(info->format);
+ else {
+ surf->info.bpp = _tbm_surface_internal_get_bpp(info->format);
+ if (!surf->info.bpp) {
+ TBM_ERR("fail to get bpp. error(%s)\n", tbm_error_str(tbm_get_last_error()));
+ goto bpp_fail;
+ }
+ }
surf->info.num_planes = info->num_planes;
surf->refcnt = 1;
uint32_t size = 0, offset = 0, stride = 0;
int32_t bo_idx = 0;
- _tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride, &bo_idx);
+ if (!_tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride, &bo_idx)) {
+ TBM_ERR("fail to get plane_data. error(%s)\n", tbm_error_str(tbm_get_last_error()));
+ goto plane_data_fail;
+ }
surf->info.planes[i].size = size;
}
for (i = 0; i < num; i++) {
if (bos[i] == NULL) {
TBM_ERR("bos[%d] is null.\n", i);
+ _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION);
goto check_bo_fail;
}
/* LCOV_EXCL_START */
check_bo_fail:
+plane_data_fail:
+bpp_fail:
for (i = 0; i < num; i++) {
if (surf->bos[i])
tbm_bo_unref(surf->bos[i]);
tbm_surface_internal_destroy(tbm_surface_h surface)
{
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface));
tbm_surface_internal_ref(tbm_surface_h surface)
{
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface));
tbm_surface_internal_unref(tbm_surface_h surface)
{
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface));
int num;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
surf = (struct _tbm_surface *)surface;
num = surf->num_bos;
+ if (!num)
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
+
TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) num_bos(%d)\n", surface, num);
_tbm_surface_mutex_unlock();
tbm_bo bo;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), NULL);
TBM_SURFACE_RETURN_VAL_IF_FAIL(bo_idx > -1, NULL);
unsigned int size;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
struct _tbm_surface *surf;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
TBM_SURFACE_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
if (plane_idx >= surf->info.num_planes) {
TBM_TRACE_SURFACE_INTERNAL("error: tbm_surface(%p) plane_idx(%d)\n", surface, plane_idx);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
int i, j;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
int i;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface));
unsigned int width;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
unsigned int height;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
tbm_format format;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
int bo_idx;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
TBM_SURFACE_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
tbm_user_data *data;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
data = user_data_lookup(&surface->user_data_list, key);
if (data) {
TBM_TRACE_SURFACE_INTERNAL("warning: user data already exist tbm_surface(%p) key(%lu)\n", surface, key);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
tbm_user_data *old_data;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
old_data = user_data_lookup(&surface->user_data_list, key);
if (!old_data) {
TBM_TRACE_SURFACE_INTERNAL("error: tbm_surface(%p) key(%lu)\n", surface, key);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
tbm_user_data *old_data;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
if (!data) {
TBM_ERR("error: tbm_surface(%p) key(%lu)\n", surface, key);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
old_data = user_data_lookup(&surface->user_data_list, key);
if (!old_data) {
TBM_TRACE_SURFACE_INTERNAL("error: tbm_surface(%p) key(%lu)\n", surface, key);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
tbm_user_data *old_data = (void *)0;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
old_data = user_data_lookup(&surface->user_data_list, key);
if (!old_data) {
TBM_TRACE_SURFACE_INTERNAL("error: tbm_surface(%p) key(%lu)\n", surface, key);
+ _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
_tbm_surface_mutex_unlock();
return 0;
}
tbm_surface_internal_set_debug_pid(tbm_surface_h surface, unsigned int pid)
{
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface));
tbm_surface_debug_data *debug_data = NULL;
debug_data = calloc(1, sizeof(tbm_surface_debug_data));
- if (!debug_data)
+ if (!debug_data) {
+ _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY);
+ TBM_ERR("fail to allocate the debug_data.");
return NULL;
+ }
if (key) debug_data->key = strdup(key);
if (value) debug_data->value = strdup(value);
return debug_data;
}
+static void
+_tbm_surface_internal_debug_data_value_update(tbm_surface_debug_data *debug_data, char *value)
+{
+ if (!debug_data->value && !value)
+ return;
+
+ if (debug_data->value && value && !strncmp(debug_data->value, value, strlen(debug_data->value)))
+ return;
+
+ if (debug_data->value)
+ free(debug_data->value);
+
+ if (value)
+ debug_data->value = strdup(value);
+ else
+ debug_data->value = NULL;
+}
+
+static tbm_surface_debug_data *
+_tbm_surface_internal_debug_data_find(struct list_head *list, char *key)
+{
+ tbm_surface_debug_data *debug_data = NULL;
+
+ if (LIST_IS_EMPTY(list))
+ return NULL;
+
+ LIST_FOR_EACH_ENTRY(debug_data, list, item_link) {
+ if (!strncmp(debug_data->key, key, strlen(debug_data->key)))
+ return debug_data;
+ }
+
+ return NULL;
+}
+
int
tbm_surface_internal_set_debug_data(tbm_surface_h surface, char *key, char *value)
{
tbm_surface_debug_data *debug_data = NULL;
- tbm_surface_debug_data *old_data = NULL, *tmp = NULL;
tbm_bufmgr bufmgr = NULL;
_tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
TBM_SURFACE_RETURN_VAL_IF_FAIL(key, 0);
TBM_SURFACE_RETURN_VAL_IF_FAIL(bufmgr, 0);
- if (!LIST_IS_EMPTY(&surface->debug_data_list)) {
- LIST_FOR_EACH_ENTRY(old_data, &surface->debug_data_list, item_link) {
- if (old_data) {
- if (!strcmp(old_data->key, key)) {
- if (old_data->value && value && !strncmp(old_data->value, value, strlen(old_data->value))) {
- TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) Already exist key(%s) and value(%s)!\n", surface, key, value);
- goto add_debug_key_list;
- }
-
- if (old_data->value)
- free(old_data->value);
-
- if (value)
- old_data->value = strdup(value);
- else
- old_data->value = NULL;
-
- goto add_debug_key_list;
- }
- }
+ debug_data = _tbm_surface_internal_debug_data_find(&surface->debug_data_list, key);
+ if (debug_data) {
+ _tbm_surface_internal_debug_data_value_update(debug_data, value);
+ } else {
+ debug_data = _tbm_surface_internal_debug_data_create(key, value);
+ if (!debug_data) {
+ TBM_ERR("error: tbm_surface(%p) key(%s) value(%s)\n", surface, key, value);
+ _tbm_surface_mutex_unlock();
+ return 0;
}
+
+ LIST_ADD(&debug_data->item_link, &surface->debug_data_list);
}
- debug_data = _tbm_surface_internal_debug_data_create(key, value);
+ /* add new debug key to list */
+ debug_data = _tbm_surface_internal_debug_data_find(&bufmgr->debug_key_list, key);
if (!debug_data) {
- TBM_ERR("error: tbm_surface(%p) key(%s) value(%s)\n", surface, key, value);
- _tbm_surface_mutex_unlock();
- return 0;
+ debug_data = _tbm_surface_internal_debug_data_create(key, NULL);
+ if (debug_data)
+ LIST_ADDTAIL(&debug_data->item_link, &bufmgr->debug_key_list);
}
TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) key(%s) value(%s)\n", surface, key, value);
- LIST_ADD(&debug_data->item_link, &surface->debug_data_list);
-
-add_debug_key_list:
- if (!LIST_IS_EMPTY(&bufmgr->debug_key_list)) {
- LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &bufmgr->debug_key_list, item_link) {
- if (!strcmp(old_data->key, key)) {
- _tbm_surface_mutex_unlock();
- return 1;
- }
- }
- }
-
- debug_data = _tbm_surface_internal_debug_data_create(key, NULL);
- LIST_ADD(&debug_data->item_link, &bufmgr->debug_key_list);
-
_tbm_surface_mutex_unlock();
return 1;
}
static void
-_tbm_surface_internal_dump_file_png(const char *file, const void *data, int width, int height, int format)
+_tbm_surface_internal_dump_file_png(const char *file, const void *data, int width, int height, int stride, int format)
{
unsigned int *blocks = (unsigned int *)data;
FILE *fp;
return;
}
+ if (setjmp(png_jmpbuf(pPngStruct))) {
+ /* if png has problem of writing the file, we get here */
+ TBM_ERR("fail to write png file.\n");
+ png_destroy_write_struct(&pPngStruct, &pPngInfo);
+ fclose(fp);
+ return;
+ }
+
png_init_io(pPngStruct, fp);
if (format == TBM_FORMAT_XRGB8888) {
pixel_size = 3;
row_pointers[y] = (png_bytep)row;
for (x = 0; x < width; ++x) {
- unsigned int curBlock = blocks[y * width + x];
+ unsigned int curBlock = blocks[(y * (stride >> 2)) + x];
if (pixel_size == 3) { // XRGB8888
row[x * pixel_size] = (curBlock & 0xFF);
case TBM_FORMAT_ARGB8888:
_tbm_surface_internal_dump_file_png(file, bo_handle.ptr,
buf_info->info.planes[0].stride >> 2,
- buf_info->info.height, TBM_FORMAT_ARGB8888);
+ buf_info->info.height,
+ buf_info->info.planes[0].stride,
+ TBM_FORMAT_ARGB8888);
break;
case TBM_FORMAT_XRGB8888:
_tbm_surface_internal_dump_file_png(file, bo_handle.ptr,
buf_info->info.planes[0].stride >> 2,
- buf_info->info.height, TBM_FORMAT_XRGB8888);
+ buf_info->info.height,
+ buf_info->info.planes[0].stride,
+ TBM_FORMAT_XRGB8888);
break;
case TBM_FORMAT_YVU420:
case TBM_FORMAT_YUV420:
} else if (buf_info->dirty_shm)
_tbm_surface_internal_dump_file_png(file, bo_handle.ptr,
buf_info->shm_stride >> 2,
- buf_info->shm_h, 0);
+ buf_info->shm_h,
+ buf_info->shm_stride, 0);
tbm_bo_unmap(buf_info->bo);
tbm_bo_unref(buf_info->bo);
memset(temp_key, 0x00, KEY_LEN + 1);
bo = surf->bos[i];
snprintf(temp_key, KEY_LEN, "_%d", tbm_bo_export(bo));
- strncat(keys, temp_key, KEY_LEN);
+ strncat(keys, temp_key, KEY_LEN + 1);
}
_tbm_surface_mutex_unlock();
buf_info->info.width = info.width * scale_factor;
buf_info->info.height = info.height * scale_factor;
buf_info->info.format = info.format;
- buf_info->info.bpp = tbm_surface_internal_get_bpp(buf_info->info.format);
+ buf_info->info.bpp = _tbm_surface_internal_get_bpp(buf_info->info.format);
+ if (!buf_info->info.bpp) {
+ TBM_ERR("fail to get bpp. error(%s)\n", tbm_error_str(tbm_get_last_error()));
+ tbm_surface_unmap(surface);
+ return;
+ }
buf_info->info.num_planes = 1;
buf_info->info.planes[0].stride = buf_info->info.width * bpp;
buf_info->info.size = buf_info->info.width * buf_info->info.height * bpp;
switch (info.format) {
case TBM_FORMAT_ARGB8888:
_tbm_surface_internal_dump_file_png(file, info.planes[0].ptr,
- info.planes[0].stride >> 2,
- info.height, TBM_FORMAT_ARGB8888);
+ info.width,
+ info.height,
+ info.planes[0].stride,
+ TBM_FORMAT_ARGB8888);
break;
case TBM_FORMAT_XRGB8888:
_tbm_surface_internal_dump_file_png(file, info.planes[0].ptr,
- info.planes[0].stride >> 2,
- info.height, TBM_FORMAT_XRGB8888);
+ info.width,
+ info.height,
+ info.planes[0].stride,
+ TBM_FORMAT_XRGB8888);
break;
case TBM_FORMAT_YVU420:
case TBM_FORMAT_YUV420:
return 0;
}
- _tbm_surface_internal_dump_file_png(file, ptr, w, h, 0);
+ _tbm_surface_internal_dump_file_png(file, ptr, w, h, stride, 0);
TBM_TRACE_SURFACE_INTERNAL("Capture %s \n", file);
return 1;
}
+
+int
+tbm_surface_internal_set_damage(tbm_surface_h surface, int x, int y, int width, int height)
+{
+ struct _tbm_surface *surf;
+
+ _tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(width > 0, 0);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(height > 0, 0);
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
+
+ surf = (struct _tbm_surface *)surface;
+
+ surf->damage.x = x;
+ surf->damage.y = y;
+ surf->damage.width = width;
+ surf->damage.height = height;
+
+ TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) x(%d) y(%d) width(%d) height(%d)\n",
+ surface, x, y, width, height);
+
+ _tbm_surface_mutex_unlock();
+
+ return 1;
+}
+
+int
+tbm_surface_internal_get_damage(tbm_surface_h surface, int *x, int *y, int *width, int *height)
+{
+ struct _tbm_surface *surf;
+
+ _tbm_surface_mutex_lock();
+ _tbm_set_last_result(TBM_ERROR_NONE);
+
+ TBM_SURFACE_RETURN_VAL_IF_FAIL(_tbm_surface_internal_is_valid(surface), 0);
+
+ surf = (struct _tbm_surface *)surface;
+
+ if (x) *x = surf->damage.x;
+ if (y) *y = surf->damage.y;
+ if (width) *width = surf->damage.width;
+ if (height) *height = surf->damage.height;
+
+ TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) x(%d) y(%d) width(%d) height(%d)\n",
+ surface, surf->damage.x, surf->damage.y, surf->damage.width, surf->damage.height);
+
+ _tbm_surface_mutex_unlock();
+
+ return 1;
+}
/*LCOV_EXCL_STOP*/