X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_surface_internal.c;h=8c6fc391112d1d19b029e0e7a164e31f73c68561;hb=e63541a42a8470996ae0dc2209b2febaaa71c390;hp=2da84bdbd979846501a2fcde58729d51039df4a2;hpb=d016f08e18a40b9fb7a01b3129e3678cd3f479d0;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c index 2da84bd..8c6fc39 100644 --- a/src/tbm_surface_internal.c +++ b/src/tbm_surface_internal.c @@ -41,16 +41,12 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include +#define TBM_SURFACE_MAGIC 0xBF021234 + static tbm_bufmgr g_surface_bufmgr; 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)) {\ @@ -61,6 +57,25 @@ void _tbm_surface_mutex_unlock(void); } \ } +#define TBM_SURFACE_RETURN_ERR_IF_FAIL(cond, error_type) {\ + if (!(cond)) {\ + TBM_ERR("'%s' failed.\n", #cond);\ + _tbm_set_last_result(error_type);\ + _tbm_surface_mutex_unlock();\ + return;\ + } \ +} + +#define TBM_SURFACE_RETURN_SET_ERR_IF_FAIL(cond, error, error_type) {\ + if (!(cond)) {\ + TBM_ERR("'%s' failed.\n", #cond);\ + error = error_type;\ + _tbm_set_last_result(error_type);\ + _tbm_surface_mutex_unlock();\ + return;\ + } \ +} + #define TBM_SURFACE_RETURN_VAL_IF_FAIL(cond, val) {\ if (!(cond)) {\ TBM_ERR("'%s' failed.\n", #cond);\ @@ -70,6 +85,26 @@ void _tbm_surface_mutex_unlock(void); } \ } + +#define TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(cond, val, error_type) {\ + if (!(cond)) {\ + TBM_ERR("'%s' failed.\n", #cond);\ + _tbm_set_last_result(error_type);\ + _tbm_surface_mutex_unlock();\ + return val;\ + } \ +} + +#define TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(cond, val, error, error_type) {\ + if (!(cond)) {\ + TBM_ERR("'%s' failed.\n", #cond);\ + error = error_type;\ + _tbm_set_last_result(error_type);\ + _tbm_surface_mutex_unlock();\ + return val;\ + } \ +} + /* LCOV_EXCL_START */ static double _tbm_surface_internal_get_time(void) @@ -250,25 +285,30 @@ _deinit_surface_bufmgr(void) /* 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) - 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_set_last_result(TBM_ERROR_INVALID_PARAMETER); - - 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 @@ -280,7 +320,6 @@ _tbm_surface_internal_query_plane_data(tbm_surface_h surface, struct _tbm_surface *surf = (struct _tbm_surface *)surface; struct _tbm_bufmgr *bufmgr = surf->bufmgr; - int ret = 0; tbm_error_e error; TBM_RETURN_VAL_IF_FAIL(bufmgr != NULL, 0); @@ -288,40 +327,13 @@ _tbm_surface_internal_query_plane_data(tbm_surface_h surface, 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) { - _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) { - _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 */ - } + error = tbm_module_bufmgr_get_plane_data(bufmgr->module, surf->info.format, plane_idx, surf->info.width, surf->info.height, size, offset, pitch, bo_idx); + if (error != TBM_ERROR_NONE) { + _tbm_set_last_result(error); + return 0; } - return ret; + return 1; } static void @@ -331,6 +343,18 @@ _tbm_surface_internal_destroy(tbm_surface_h surface) tbm_bufmgr bufmgr = surface->bufmgr; tbm_user_data *old_data = NULL, *tmp = NULL; tbm_surface_debug_data *debug_old_data = NULL, *debug_tmp = NULL; + tbm_surface_destroy_func_info *func_info = NULL, *func_next = NULL; + + if (!LIST_IS_EMPTY(&surface->destroy_funcs)) { + LIST_FOR_EACH_ENTRY_SAFE(func_info, func_next, &surface->destroy_funcs, item_link) { + func_info->destroy_func(surface, func_info->user_data); + } + TBM_DBG("free destroy_funcs %p\n", surface); + LIST_FOR_EACH_ENTRY_SAFE(func_info, func_next, &surface->destroy_funcs, item_link) { + LIST_DEL(&func_info->item_link); + free(func_info); + } + } /* destory the user_data_list */ if (!LIST_IS_EMPTY(&surface->user_data_list)) { @@ -353,6 +377,12 @@ _tbm_surface_internal_destroy(tbm_surface_h surface) } LIST_DEL(&surface->item_link); + surface->magic = 0; + + if (surface->hal_surface) { + hal_tbm_surface_free(surface->hal_surface); + surface->hal_surface = NULL; + } free(surface); surface = NULL; @@ -563,6 +593,384 @@ _tbm_surface_internal_get_bpp(tbm_format format) return bpp; } +static struct _tbm_surface * +_tbm_surface_internal_create_surface(tbm_bufmgr bufmgr, int width, int height, int format, int flags, tbm_error_e *error) +{ + struct _tbm_surface *surf = NULL; + uint32_t size = 0, offset = 0, stride = 0, bo_size = 0; + int i, j, bo_idx; + + surf = calloc(1, sizeof(struct _tbm_surface)); + if (!surf) { + /* LCOV_EXCL_START */ + TBM_ERR("fail to alloc surf\n"); + *error = 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); + if (!surf->info.bpp) { + TBM_ERR("fail to get bpp from format(%d), error(%s)\n", format, tbm_error_str(*error)); + *error = 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 from format(%d), error(%s)\n", format, tbm_error_str(*error)); + *error = tbm_get_last_error(); + goto num_planes_fail; + } + surf->refcnt = 1; + + /* get size, stride and offset bo_idx */ + for (i = 0; i < surf->info.num_planes; i++) { + if (!_tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride, &bo_idx)) { + TBM_ERR("fail to query plane data\n"); + *error = tbm_get_last_error(); + goto query_plane_data_fail; + } + + surf->info.planes[i].size = size; + surf->info.planes[i].offset = offset; + surf->info.planes[i].stride = stride; + surf->planes_bo_idx[i] = bo_idx; + } + + surf->num_bos = 1; + + for (i = 0; i < surf->info.num_planes; i++) { + surf->info.size += surf->info.planes[i].size; + + if (surf->num_bos < surf->planes_bo_idx[i] + 1) + surf->num_bos = surf->planes_bo_idx[i] + 1; + } + + surf->flags = flags; + + for (i = 0; i < surf->num_bos; i++) { + bo_size = 0; + for (j = 0; j < surf->info.num_planes; j++) { + if (surf->planes_bo_idx[j] == i) + bo_size += surf->info.planes[j].size; + } + + surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_format(bufmgr, format, i, width, height, surf->info.bpp/8, flags, error); + if (!surf->bos[i]) { + surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags); + if (!surf->bos[i]) { + TBM_ERR("fail to alloc bo idx:%d\n", i); + *error = tbm_get_last_error(); + goto alloc_bo_fail; + } + } + + _tbm_bo_set_surface(surf->bos[i], surf); + } + + *error = TBM_ERROR_NONE; + + return surf; + +alloc_bo_fail: + for (j = 0; j < i; j++) { + if (surf->bos[j]) + tbm_bo_unref(surf->bos[j]); + } +query_plane_data_fail: +bpp_fail: +num_planes_fail: + free(surf); +alloc_surf_fail: + + return NULL; +} + +static struct _tbm_surface * +_tbm_surface_internal_hal_tbm_create_surface(tbm_bufmgr bufmgr, int width, int height, int format, int flags, tbm_error_e *error) +{ + struct _tbm_surface *surf = NULL; + uint32_t size = 0, offset = 0, stride = 0, bo_size = 0; + int i, j, bo_idx; + hal_tbm_surface *hal_surface = NULL; + hal_tbm_bo **hal_bos = NULL; + int num_bos = 0; + + surf = calloc(1, sizeof(struct _tbm_surface)); + if (!surf) { + /* LCOV_EXCL_START */ + TBM_ERR("fail to alloc surf"); + *error = TBM_ERROR_OUT_OF_MEMORY; + goto alloc_surf_fail; + /* LCOV_EXCL_STOP */ + } + surf->refcnt = 1; + + 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); + if (!surf->info.bpp) { + TBM_ERR("fail to get bpp from format(%d), error(%s)", format, tbm_error_str(*error)); + *error = tbm_get_last_error(); + goto bpp_fail; + } + surf->flags = flags; + + // get number of planes + surf->info.num_planes = _tbm_surface_internal_get_num_planes(format); + if (!surf->info.num_planes) { + TBM_ERR("fail to get num_planes from format(%d), error(%s)", format, tbm_error_str(*error)); + *error = tbm_get_last_error(); + goto num_planes_fail; + } + + hal_surface = hal_tbm_bufmgr_alloc_surface(bufmgr->hal_bufmgr, (uint32_t)width, (uint32_t)height, (hal_tbm_format)format, (hal_tbm_bo_memory_type)flags, NULL, 0, (hal_tbm_error *)error); + if (hal_surface) { + // set hal_surface + surf->hal_surface = hal_surface; + + // set infomation of planes + for (i = 0; i < surf->info.num_planes; i++) { + *error = (tbm_error_e)hal_tbm_surface_get_plane_data(hal_surface, i, &size, &offset, &stride, &bo_idx); + if (*error != TBM_ERROR_NONE) { + goto query_plane_data_fail; + } + surf->info.planes[i].size = size; + surf->info.planes[i].offset = offset; + surf->info.planes[i].stride = stride; + surf->planes_bo_idx[i] = bo_idx; + } + + // set infomation of bos + hal_bos = hal_tbm_surface_get_bos(hal_surface, &num_bos, (hal_tbm_error *)error); + if (!hal_bos) { + TBM_ERR("fail to get bos, error(%s)", tbm_error_str(*error)); + goto get_bos_fail; + } + surf->num_bos = num_bos; + + for (i = 0; i < surf->info.num_planes; i++) { + surf->info.size += surf->info.planes[i].size; + + if (surf->num_bos < surf->planes_bo_idx[i] + 1) + surf->num_bos = surf->planes_bo_idx[i] + 1; + } + + for (i = 0; i < num_bos; i++) { + surf->bos[i] = tbm_bo_alloc_with_bo_data(bufmgr, (tbm_backend_bo_data *)hal_bos[i], flags); + if (!surf->bos[i]) { + TBM_ERR("fail to alloc bo idx:%d", i); + *error = tbm_get_last_error(); + goto get_bo_fail; + } + + _tbm_bo_set_surface(surf->bos[i], surf); + } + } else { + // set infomation of planes + for (i = 0; i < surf->info.num_planes; i++) { + if (!_tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride, &bo_idx)) { + TBM_ERR("fail to query plane data"); + *error = tbm_get_last_error(); + goto query_plane_data_fail; + } + surf->info.planes[i].size = size; + surf->info.planes[i].offset = offset; + surf->info.planes[i].stride = stride; + surf->planes_bo_idx[i] = bo_idx; + } + + // count number of bos + surf->num_bos = 1; + for (i = 0; i < surf->info.num_planes; i++) { + surf->info.size += surf->info.planes[i].size; + + if (surf->num_bos < surf->planes_bo_idx[i] + 1) + surf->num_bos = surf->planes_bo_idx[i] + 1; + } + + // set infomation of bos + for (i = 0; i < surf->num_bos; i++) { + bo_size = 0; + for (j = 0; j < surf->info.num_planes; j++) { + if (surf->planes_bo_idx[j] == i) + bo_size += surf->info.planes[j].size; + } + + surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_format(bufmgr, format, i, width, height, surf->info.bpp / 8, flags, error); + if (*error == TBM_ERROR_NOT_SUPPORTED) { + surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags); + if (!surf->bos[i]) { + TBM_ERR("fail to alloc bo idx:%d", i); + *error = tbm_get_last_error(); + goto get_bo_fail; + } + } + + _tbm_bo_set_surface(surf->bos[i], surf); + } + } + + *error = TBM_ERROR_NONE; + + return surf; + +get_bo_fail: +get_bos_fail: +query_plane_data_fail: + if (hal_surface) { + hal_tbm_surface_free(hal_surface); + } else { + for (j = 0; j < i; j++) { + if (surf->bos[j]) + tbm_bo_unref(surf->bos[j]); + } + } +num_planes_fail: +bpp_fail: + if (surf) + free(surf); +alloc_surf_fail: + + return NULL; +} + +static struct _tbm_surface * +_tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error) +{ + struct _tbm_surface *surf = NULL; + uint32_t size = 0, offset = 0, stride = 0; + int i, j, bo_idx; + hal_tbm_surface *hal_surface = NULL; + hal_tbm_bo **hal_bos = NULL; + int num_bos = 0; + int flags; + + surf = calloc(1, sizeof(struct _tbm_surface)); + if (!surf) { + /* LCOV_EXCL_START */ + TBM_ERR("fail to alloc surf"); + *error = TBM_ERROR_OUT_OF_MEMORY; + goto alloc_surf_fail; + /* LCOV_EXCL_STOP */ + } + surf->refcnt = 1; + + 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); + if (!surf->info.bpp) { + TBM_ERR("fail to get bpp from format(%d), error(%s)", format, tbm_error_str(*error)); + *error = tbm_get_last_error(); + goto bpp_fail; + } + + // get number of planes + surf->info.num_planes = _tbm_surface_internal_get_num_planes(format); + if (!surf->info.num_planes) { + TBM_ERR("fail to get num_planes from format(%d), error(%s)", format, tbm_error_str(*error)); + *error = tbm_get_last_error(); + goto num_planes_fail; + } + + // import surface + hal_surface = hal_tbm_bufmgr_import_surface(bufmgr->hal_bufmgr, + (uint32_t)width, + (uint32_t)height, + (hal_tbm_format)format, + (hal_tbm_surface_buffer_data *)buffer_data, + (hal_tbm_error *)error); + if (!hal_surface) { + TBM_ERR("hal_tbm_bufmgr_import_surface failed.(width:%d height:%d format:%d error:%s)", + width, height, format, tbm_error_str(*error)); + goto import_surface_fail; + } + surf->hal_surface = hal_surface; + + // set infomation of planes + for (i = 0; i < surf->info.num_planes; i++) { + *error = (tbm_error_e)hal_tbm_surface_get_plane_data(hal_surface, i, &size, &offset, &stride, &bo_idx); + if (*error != TBM_ERROR_NONE) { + goto query_plane_data_fail; + } + surf->info.planes[i].size = size; + surf->info.planes[i].offset = offset; + surf->info.planes[i].stride = stride; + surf->planes_bo_idx[i] = bo_idx; + } + + // set infomation of bos + hal_bos = hal_tbm_surface_get_bos(hal_surface, &num_bos, (hal_tbm_error *)error); + if (!hal_bos) { + TBM_ERR("fail to get bos, error(%s)", tbm_error_str(*error)); + goto get_bos_fail; + } + surf->num_bos = num_bos; + + for (i = 0; i < surf->info.num_planes; i++) { + surf->info.size += surf->info.planes[i].size; + + if (surf->num_bos < surf->planes_bo_idx[i] + 1) + surf->num_bos = surf->planes_bo_idx[i] + 1; + } + + // get memory_types(bo flags) + flags = (int)hal_tbm_bo_get_memory_types(hal_bos[0], (hal_tbm_error *)error); + if (*error != TBM_ERROR_NONE) { + TBM_ERR("hal_tbm_bo_get_memory_types failed."); + goto get_memory_types_fail; + } + surf->flags = flags; + + for (i = 0; i < num_bos; i++) { + surf->bos[i] = tbm_bo_alloc_with_bo_data(bufmgr, (tbm_backend_bo_data *)hal_bos[i], flags); + if (!surf->bos[i]) { + TBM_ERR("fail to alloc bo idx:%d", i); + *error = tbm_get_last_error(); + goto get_bo_fail; + } + + _tbm_bo_set_surface(surf->bos[i], surf); + } + + *error = TBM_ERROR_NONE; + + return surf; + +get_bo_fail: +get_memory_types_fail: +get_bos_fail: +query_plane_data_fail: + if (hal_surface) { + hal_tbm_surface_free(hal_surface); + } else { + for (j = 0; j < i; j++) { + if (surf->bos[j]) + tbm_bo_unref(surf->bos[j]); + } + } +import_surface_fail: +num_planes_fail: +bpp_fail: + if (surf) + free(surf); +alloc_surf_fail: + + return NULL; +} + int tbm_surface_internal_is_valid(tbm_surface_h surface) { @@ -590,7 +998,6 @@ tbm_surface_internal_query_supported_formats(uint32_t **formats, uint32_t *num) { struct _tbm_bufmgr *bufmgr; - int ret = 0; bool bufmgr_initialized = false; tbm_error_e error; @@ -602,40 +1009,21 @@ tbm_surface_internal_query_supported_formats(uint32_t **formats, if (!g_surface_bufmgr) { _init_surface_bufmgr(); + if (!g_surface_bufmgr) { + TBM_ERR("fail bufmgr initialization\n"); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); + goto fail; + } LIST_INITHEAD(&g_surface_bufmgr->surf_list); bufmgr_initialized = true; } - bufmgr = g_surface_bufmgr; - - 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) { - /* LCOV_EXCL_START */ - TBM_ERR("Fail to surface_supported_format. error(%d)\n", error); - goto fail; - /* LCOV_EXCL_START */ - } - ret = 1; - } else { - 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 */ - } + bufmgr = g_surface_bufmgr; + + error = tbm_module_bufmgr_get_supported_formats(bufmgr->module, formats, num); + if (error != TBM_ERROR_NONE) { + _tbm_set_last_result(error); + goto fail; } TBM_TRACE_SURFACE_INTERNAL("tbm_bufmgr(%p) format num(%u)\n", g_surface_bufmgr, *num); @@ -647,7 +1035,7 @@ tbm_surface_internal_query_supported_formats(uint32_t **formats, _tbm_surface_mutex_unlock(); - return ret; + return 1; /* LCOV_EXCL_START */ fail: @@ -713,17 +1101,8 @@ tbm_surface_internal_create_with_flags(int width, int height, { struct _tbm_bufmgr *bufmgr; struct _tbm_surface *surf = NULL; - uint32_t size = 0; - uint32_t offset = 0; - uint32_t stride = 0; - uint32_t bo_size = 0; - int bo_idx; - int i, j; + tbm_error_e error = TBM_ERROR_INVALID_OPERATION; 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); @@ -733,6 +1112,11 @@ tbm_surface_internal_create_with_flags(int width, int height, if (!g_surface_bufmgr) { _init_surface_bufmgr(); + if (!g_surface_bufmgr) { + TBM_ERR("fail bufmgr initialization\n"); + error = TBM_ERROR_INVALID_OPERATION; + goto check_valid_fail; + } LIST_INITHEAD(&g_surface_bufmgr->surf_list); bufmgr_initialized = true; } @@ -740,219 +1124,53 @@ tbm_surface_internal_create_with_flags(int width, int height, bufmgr = g_surface_bufmgr; if (!TBM_BUFMGR_IS_VALID(bufmgr)) { TBM_ERR("The bufmgr is invalid\n"); + error = TBM_ERROR_INVALID_PARAMETER; goto check_valid_fail; } - surf = calloc(1, sizeof(struct _tbm_surface)); - 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->bufmgr = bufmgr; - surf->info.width = width; - surf->info.height = height; - surf->info.format = 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())); - goto num_planes_fail; - } - surf->refcnt = 1; - - /* get size, stride and offset bo_idx */ - for (i = 0; i < surf->info.num_planes; i++) { - if (!_tbm_surface_internal_query_plane_data(surf, i, &size, - &offset, &stride, &bo_idx)) { - TBM_ERR("fail to query plane data\n"); - goto query_plane_data_fail; - } - - surf->info.planes[i].size = size; - surf->info.planes[i].offset = offset; - surf->info.planes[i].stride = stride; - surf->planes_bo_idx[i] = bo_idx; - } - - surf->num_bos = 1; - - for (i = 0; i < surf->info.num_planes; i++) { - surf->info.size += surf->info.planes[i].size; - - if (surf->num_bos < surf->planes_bo_idx[i] + 1) - surf->num_bos = surf->planes_bo_idx[i] + 1; - } - - surf->flags = flags; - - for (i = 0; i < surf->num_bos; i++) { - bo_size = 0; - for (j = 0; j < surf->info.num_planes; j++) { - if (surf->planes_bo_idx[j] == i) - bo_size += surf->info.planes[j].size; + if (bufmgr->use_hal_tbm) { + surf = _tbm_surface_internal_hal_tbm_create_surface(bufmgr, width, height, format, flags, &error); + if (!surf) { + TBM_ERR("_tbm_surface_internal_hal_tbm_create_surface failed."); + goto surface_alloc_fail; } - - 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"); - _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); - goto alloc_bo_fail; - } - - bo->bufmgr = surf->bufmgr; - - _tbm_bufmgr_mutex_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); - _tbm_set_last_result(error); - free(bo); - _tbm_bufmgr_mutex_unlock(); - 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); - - _tbm_bufmgr_mutex_unlock(); - - surf->bos[i] = bo; - /* LCOV_EXCL_STOP */ - } else if (bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format && (flags & TBM_BO_TILED)) { - bo = calloc(1, sizeof(struct _tbm_bo)); - if (!bo) { - TBM_ERR("fail to alloc bo struct\n"); - _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); - goto alloc_bo_fail; - } - - bo->bufmgr = surf->bufmgr; - - _tbm_bufmgr_mutex_lock(); - - bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format(bufmgr->bufmgr_data, width, height, surf->info.bpp/8, format, flags, i, &error); - if (!bo_data) { - TBM_ERR("fail to alloc bo priv. error(%d)\n", error); - _tbm_set_last_result(error); - free(bo); - _tbm_bufmgr_mutex_unlock(); - 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); - - _tbm_bufmgr_mutex_unlock(); - - surf->bos[i] = bo; - - } 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 (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"); - _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); - goto alloc_bo_fail; - } - - bo->bufmgr = surf->bufmgr; - - _tbm_bufmgr_mutex_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"); - _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - free(bo); - _tbm_bufmgr_mutex_unlock(); - 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); - - _tbm_bufmgr_mutex_unlock(); - - surf->bos[i] = bo; - /* LCOV_EXCL_STOP */ - } 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 { + surf = _tbm_surface_internal_create_surface(bufmgr, width, height, format, flags, &error); + if (!surf) { + TBM_ERR("_tbm_surface_internal_create_surface failed."); + goto surface_alloc_fail; } - - _tbm_bo_set_surface(surf->bos[i], surf); } - TBM_TRACE_SURFACE_INTERNAL("width(%d) height(%d) format(%s) flags(%d) tbm_surface(%p)\n", width, height, - _tbm_surface_internal_format_to_str(format), flags, surf); + TBM_TRACE_SURFACE_INTERNAL("width(%d) height(%d) format(%s) flags(%d) tbm_surface(%p)\n", + width, height, _tbm_surface_internal_format_to_str(format), flags, surf); LIST_INITHEAD(&surf->user_data_list); LIST_INITHEAD(&surf->debug_data_list); + LIST_INITHEAD(&surf->destroy_funcs); LIST_ADD(&surf->item_link, &bufmgr->surf_list); + _tbm_set_last_result(error); _tbm_surface_mutex_unlock(); return surf; /* LCOV_EXCL_START */ -alloc_bo_fail: - for (j = 0; j < i; j++) { - if (surf->bos[j]) - tbm_bo_unref(surf->bos[j]); - } -query_plane_data_fail: -bpp_fail: -num_planes_fail: - free(surf); -alloc_surf_fail: + +surface_alloc_fail: check_valid_fail: if (bufmgr_initialized && bufmgr) { LIST_DELINIT(&bufmgr->surf_list); _deinit_surface_bufmgr(); } - _tbm_surface_mutex_unlock(); TBM_ERR("error: width(%d) height(%d) format(%s) flags(%d)\n", - width, height, - _tbm_surface_internal_format_to_str(format), flags); + width, height, _tbm_surface_internal_format_to_str(format), flags); + + _tbm_set_last_result(error); + _tbm_surface_mutex_unlock(); + /* LCOV_EXCL_STOP */ return NULL; @@ -978,6 +1196,11 @@ tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, if (!g_surface_bufmgr) { _init_surface_bufmgr(); + if (!g_surface_bufmgr) { + TBM_ERR("fail bufmgr initialization\n"); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); + goto check_valid_fail; + } LIST_INITHEAD(&g_surface_bufmgr->surf_list); bufmgr_initialized = true; } @@ -998,6 +1221,7 @@ tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, /* LCOV_EXCL_STOP */ } + surf->magic = TBM_SURFACE_MAGIC; surf->bufmgr = bufmgr; surf->info.width = info->width; surf->info.height = info->height; @@ -1066,6 +1290,7 @@ tbm_surface_internal_create_with_bos(tbm_surface_info_s *info, LIST_INITHEAD(&surf->user_data_list); LIST_INITHEAD(&surf->debug_data_list); + LIST_INITHEAD(&surf->destroy_funcs); LIST_ADD(&surf->item_link, &bufmgr->surf_list); @@ -1118,6 +1343,8 @@ tbm_surface_internal_destroy(tbm_surface_h surface) if (surface->refcnt == 0) _tbm_surface_internal_destroy(surface); + else // if (surface->refcnt < 0) + _tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER); _tbm_surface_mutex_unlock(); } @@ -1621,11 +1848,44 @@ _tbm_surface_internal_debug_data_create(char *key, char *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(); @@ -1638,53 +1898,30 @@ tbm_surface_internal_set_debug_data(tbm_surface_h surface, char *key, char *valu 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; @@ -1767,12 +2004,13 @@ _tbm_surface_internal_dump_file_raw(const char *file, void *data1, int size1, } static void -_tbm_surface_internal_dump_file_png(const char *file, 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; int pixel_size; png_bytep *row_pointers; - int depth = 8; + int depth = 8, y; if (_tbm_surface_check_file_is_symbolic_link(file)) TBM_ERR("%s is symbolic link\n", file); @@ -1796,6 +2034,14 @@ _tbm_surface_internal_dump_file_png(const char *file, void *data, int width, int 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; @@ -1830,12 +2076,43 @@ _tbm_surface_internal_dump_file_png(const char *file, void *data, int width, int return; } - for (int y = 0; y < height; ++y) - row_pointers[y] = data + width * pixel_size * y; + for (y = 0; y < height; ++y) { + png_bytep row; + int x = 0; + + row = png_malloc(pPngStruct, sizeof(png_byte) * width * pixel_size); + if (!row) { + TBM_ERR("fail to allocate the png row.\n"); + for (x = 0; x < y; x++) + png_free(pPngStruct, row_pointers[x]); + png_free(pPngStruct, row_pointers); + png_destroy_write_struct(&pPngStruct, &pPngInfo); + fclose(fp); + return; + } + row_pointers[y] = (png_bytep)row; + + for (x = 0; x < width; ++x) { + unsigned int curBlock = blocks[(y * (stride >> 2)) + x]; + + if (pixel_size == 3) { // XRGB8888 + row[x * pixel_size] = (curBlock & 0xFF); + row[1 + x * pixel_size] = (curBlock >> 8) & 0xFF; + row[2 + x * pixel_size] = (curBlock >> 16) & 0xFF; + } else { // ARGB8888 + row[x * pixel_size] = (curBlock & 0xFF); + row[1 + x * pixel_size] = (curBlock >> 8) & 0xFF; + row[2 + x * pixel_size] = (curBlock >> 16) & 0xFF; + row[3 + x * pixel_size] = (curBlock >> 24) & 0xFF; + } + } + } png_write_image(pPngStruct, row_pointers); png_write_end(pPngStruct, pPngInfo); + for (y = 0; y < height; y++) + png_free(pPngStruct, row_pointers[y]); png_free(pPngStruct, row_pointers); png_destroy_write_struct(&pPngStruct, &pPngInfo); @@ -1987,12 +2264,16 @@ tbm_surface_internal_dump_end(void) 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: @@ -2027,7 +2308,8 @@ tbm_surface_internal_dump_end(void) } 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); @@ -2145,7 +2427,7 @@ static char *_tbm_surface_internal_get_keys(tbm_surface_h surface) 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(); @@ -2463,13 +2745,17 @@ tbm_surface_internal_capture_buffer(tbm_surface_h surface, const char *path, con 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: @@ -2532,7 +2818,7 @@ tbm_surface_internal_capture_shm_buffer(void *ptr, int w, int h, int stride, 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); @@ -2590,4 +2876,152 @@ tbm_surface_internal_get_damage(tbm_surface_h surface, int *x, int *y, int *widt return 1; } + +int +tbm_surface_internal_add_destroy_handler(tbm_surface_h surface, tbm_surface_internal_destroy_handler func, void *user_data) +{ + struct _tbm_surface *surf; + tbm_surface_destroy_func_info *func_info = 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(func != NULL, 0); + + surf = (struct _tbm_surface *)surface; + LIST_FOR_EACH_ENTRY(func_info, &surf->destroy_funcs, item_link) { + if (func_info->destroy_func == func && func_info->user_data == user_data) { + TBM_ERR("can't add twice"); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); + _tbm_surface_mutex_unlock(); + return 0; + } + } + + func_info = calloc(1, sizeof(tbm_surface_destroy_func_info)); + if (func_info == NULL) { + TBM_ERR("alloc failed"); + _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); + _tbm_surface_mutex_unlock(); + return 0; + } + + func_info->destroy_func = func; + func_info->user_data = user_data; + + LIST_ADDTAIL(&func_info->item_link, &surf->destroy_funcs); + + _tbm_surface_mutex_unlock(); + + return 1; +} + +void +tbm_surface_internal_remove_destroy_handler(tbm_surface_h surface, tbm_surface_internal_destroy_handler func, void *user_data) +{ + struct _tbm_surface *surf; + tbm_surface_destroy_func_info *func_info = NULL, *next = NULL; + + _tbm_surface_mutex_lock(); + _tbm_set_last_result(TBM_ERROR_NONE); + + TBM_SURFACE_RETURN_IF_FAIL(_tbm_surface_internal_is_valid(surface)); + TBM_SURFACE_RETURN_IF_FAIL(func != NULL); + + surf = (struct _tbm_surface *)surface; + LIST_FOR_EACH_ENTRY_SAFE(func_info, next, &surf->destroy_funcs, item_link) { + if (func_info->destroy_func != func || func_info->user_data != user_data) + continue; + + LIST_DEL(&func_info->item_link); + free(func_info); + + _tbm_surface_mutex_unlock(); + + return; + } + + _tbm_surface_mutex_unlock(); +} + +tbm_surface_buffer_data * +tbm_surface_internal_export(tbm_surface_h surface, tbm_error_e *error) +{ + tbm_surface_buffer_data *buffer_data = NULL; + struct _tbm_surface *surf; + struct _tbm_bufmgr *bufmgr; + + _tbm_surface_mutex_lock(); + + surf = (struct _tbm_surface *)surface; + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(_tbm_surface_internal_is_valid(surface), NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + bufmgr = surf->bufmgr; + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + // this function supports when it comes to be use_hal. + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr->use_hal_tbm, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + // export a surface + buffer_data = (tbm_surface_buffer_data *)hal_tbm_surface_export((hal_tbm_surface *)surf->hal_surface, + (hal_tbm_error *)error); + TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(buffer_data != NULL, NULL, *error); + + TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) buffer_data(%p)", surface, buffer_data); + + if (error) + *error = TBM_ERROR_NONE; + + _tbm_set_last_result(TBM_ERROR_NONE); + _tbm_surface_mutex_unlock(); + + return buffer_data; +} + +tbm_surface_h +tbm_surface_internal_import(tbm_surface_info_s *surface_info, tbm_surface_buffer_data *buffer_data, tbm_error_e *error) +{ + struct _tbm_surface *surf; + struct _tbm_bufmgr *bufmgr; + + _tbm_surface_mutex_lock(); + + bufmgr = g_surface_bufmgr; + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + // this function supports when it comes to be use_hal. + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr->use_hal_tbm, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info->width > 0, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info->height > 0, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(buffer_data != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + // import a surface + surf = _tbm_surface_internal_hal_tbm_import_surface(bufmgr, + (int)surface_info->width, + (int)surface_info->height, + (int)surface_info->format, + buffer_data, + error); + TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(surf != NULL, NULL, *error); + + LIST_INITHEAD(&surf->user_data_list); + LIST_INITHEAD(&surf->debug_data_list); + LIST_INITHEAD(&surf->destroy_funcs); + + LIST_ADD(&surf->item_link, &bufmgr->surf_list); + + TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p)", surf); + + if (error) + *error = TBM_ERROR_NONE; + + _tbm_set_last_result(TBM_ERROR_NONE); + _tbm_surface_mutex_unlock(); + + return (tbm_surface_h)surf; +} + /*LCOV_EXCL_STOP*/