From ee88e8d7fdb9601cf1d79d203701e2f9d2ba1ca5 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Tue, 22 Jun 2021 15:24:37 +0900 Subject: [PATCH] tbm_module: add tbm_bo_data structure and use it The tbm_bo_data encapsulates the backend bo_data. The tbm_module can manage the backend bo_data with this tbm_bo_data. Change-Id: I299475b9c6f1619ef00e0968f0c43152cddf9bdd --- src/tbm_bufmgr.c | 8 +- src/tbm_bufmgr_backend.c | 4 +- src/tbm_bufmgr_int.h | 6 +- src/tbm_module.c | 260 +++++++++++++++++++++++++++++++++------------ src/tbm_module.h | 38 ++++--- src/tbm_surface_internal.c | 4 +- 6 files changed, 226 insertions(+), 94 deletions(-) diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c index 5d941d6..932bfb8 100644 --- a/src/tbm_bufmgr.c +++ b/src/tbm_bufmgr.c @@ -846,9 +846,8 @@ tbm_bufmgr_internal_find_bo(tbm_bufmgr bufmgr, tbm_bo bo) return NULL; LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { - if (bo2->bo_data == bo->bo_data) { + if (tbm_module_compare_bo_data(bufmgr->module, bo2->bo_data, bo->bo_data)) return bo2; - } } return NULL; @@ -858,7 +857,7 @@ tbm_bo tbm_bufmgr_internal_alloc_bo(tbm_bufmgr bufmgr, int size, int flags, tbm_error_e *error) { tbm_bo bo; - tbm_backend_bo_data *bo_data; + tbm_bo_data *bo_data; _tbm_bufmgr_check_bo_cnt(bufmgr); @@ -880,7 +879,6 @@ tbm_bufmgr_internal_alloc_bo(tbm_bufmgr bufmgr, int size, int flags, tbm_error_e /* LCOV_EXCL_STOP */ } bo->bo_data = bo_data; - bo->priv = (void *)bo_data; // TODO: this will be DEPRECATED. _tbm_bufmgr_initialize_bo(bufmgr, bo, flags); @@ -935,7 +933,7 @@ fail: } tbm_bo -tbm_bufmgr_internal_alloc_bo_with_bo_data(tbm_bufmgr bufmgr, tbm_backend_bo_data *bo_data, int flags) +tbm_bufmgr_internal_alloc_bo_with_bo_data(tbm_bufmgr bufmgr, tbm_bo_data *bo_data, int flags) { tbm_bo bo, bo2 = NULL; diff --git a/src/tbm_bufmgr_backend.c b/src/tbm_bufmgr_backend.c index e49ef24..ff6050f 100644 --- a/src/tbm_bufmgr_backend.c +++ b/src/tbm_bufmgr_backend.c @@ -108,12 +108,12 @@ void *tbm_backend_get_priv_from_bufmgr(tbm_bufmgr bufmgr) void tbm_backend_set_bo_priv(tbm_bo bo, void *bo_priv) { - bo->priv = bo_priv; + bo->bo_data->priv = bo_priv; } void *tbm_backend_get_bo_priv(tbm_bo bo) { - return bo->priv; + return bo->bo_data->priv; } int tbm_backend_is_display_server(void) diff --git a/src/tbm_bufmgr_int.h b/src/tbm_bufmgr_int.h index c48cfd6..1a035cf 100644 --- a/src/tbm_bufmgr_int.h +++ b/src/tbm_bufmgr_int.h @@ -188,7 +188,7 @@ struct _tbm_bo { int lock_cnt; /* lock count of bo */ unsigned int map_cnt; /* device map count */ - tbm_backend_bo_data *bo_data; /* bo data of the backend module */ + tbm_bo_data *bo_data; /* bo data of the module */ int get_from_surface_data; /* bo_data has be detroyed by surface_data */ }; @@ -251,7 +251,7 @@ struct _tbm_surface { int height; } damage; - tbm_surface_data *surface_data; /* surface data of the backend module */ + tbm_surface_data *surface_data; /* surface data of the module */ }; typedef struct { @@ -313,7 +313,7 @@ tbm_bo tbm_bufmgr_internal_find_bo(tbm_bufmgr bufmgr, tbm_bo bo); tbm_bo tbm_bufmgr_internal_alloc_bo(tbm_bufmgr bufmgr, int size, int flags, tbm_error_e *error); tbm_bo tbm_bufmgr_internal_alloc_bo_with_format(tbm_bufmgr bufmgr, int format, int bo_idx, int width, int bpp, int height, tbm_bo_memory_type flags, tbm_error_e *error); -tbm_bo tbm_bufmgr_internal_alloc_bo_with_bo_data(tbm_bufmgr bufmgr, tbm_backend_bo_data *bo_data, int flags); +tbm_bo tbm_bufmgr_internal_alloc_bo_with_bo_data(tbm_bufmgr bufmgr, tbm_bo_data *bo_data, int flags); tbm_bo tbm_bufmgr_internal_import_bo_with_key(tbm_bufmgr bufmgr, tbm_key key, tbm_error_e *error); tbm_bo tbm_bufmgr_internal_import_bo_with_fd(tbm_bufmgr bufmgr, tbm_fd fd, tbm_error_e *error); diff --git a/src/tbm_module.c b/src/tbm_module.c index 276098c..c30c3fc 100644 --- a/src/tbm_module.c +++ b/src/tbm_module.c @@ -747,18 +747,29 @@ tbm_module_import_surface_data(tbm_module *module, int width, int height, int fo return surface_data; } -tbm_backend_bo_data * +tbm_bo_data * tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error) { - tbm_backend_bo_data *bo_data = NULL; + tbm_bo_data *bo_data = NULL; tbm_backend_bufmgr_func *bufmgr_func = NULL; tbm_bufmgr_backend backend = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + bo_data = calloc(1, sizeof(struct _tbm_bo_data)); + if (!bo_data) { + TBM_ERR("memory allocation failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + } + switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error); + bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error); + if (!bo_data->hal_bo) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL); + } break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -766,7 +777,11 @@ tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = module->bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error); + bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error); + if (!bo_data->backend_bo_data) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL); + } break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -774,33 +789,48 @@ tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = (void *)module->backend->bo_alloc(bo, size, flags); + bo_data->priv = (void *)backend->bo_alloc(bo, size, flags); *error = TBM_ERROR_NONE; + free(bo_data); break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + free(bo_data); break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; } -tbm_backend_bo_data * +tbm_bo_data * tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width, int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error) { - tbm_backend_bo_data *bo_data = NULL; + tbm_bo_data *bo_data = NULL; tbm_backend_bufmgr_func *bufmgr_func = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + bo_data = calloc(1, sizeof(struct _tbm_bo_data)); + if (!bo_data) { + TBM_ERR("memory allocation failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + } + switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr, + bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr, format, bo_idx, width, height, bpp, (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error); + if (!bo_data->hal_bo) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL); + } break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -811,37 +841,55 @@ tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, return NULL; } - bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error); + bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error); + if (!bo_data->backend_bo_data) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL); + } break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); TBM_ERR("error: not supported tbm_bufmgr_internal_alloc_bo_with_format."); *error = TBM_ERROR_NOT_SUPPORTED; + free(bo_data); break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + free(bo_data); break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; } - -tbm_backend_bo_data * +tbm_bo_data * tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error) { - tbm_backend_bo_data *bo_data = NULL; + tbm_bo_data *bo_data = NULL; tbm_backend_bufmgr_func *bufmgr_func = NULL; tbm_bufmgr_backend backend = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + bo_data = calloc(1, sizeof(struct _tbm_bo_data)); + if (!bo_data) { + TBM_ERR("memory allocation failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + } + switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error); + bo_data->hal_bo = hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error); + if (!bo_data->hal_bo) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL); + } break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -849,7 +897,11 @@ tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error); + bo_data->backend_bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error); + if (!bo_data->backend_bo_data) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL); + } break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -857,34 +909,51 @@ tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = (void *)backend->bo_import_fd(bo, fd); - if (!bo_data) + bo_data->priv = (void *)backend->bo_import_fd(bo, fd); + if (!bo_data->priv) { *error = TBM_ERROR_INVALID_OPERATION; - else + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->priv, NULL); + } else { *error = TBM_ERROR_NONE; + } break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + free(bo_data); break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; } -tbm_backend_bo_data * +tbm_bo_data * tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error) { - tbm_backend_bo_data *bo_data = NULL; + tbm_bo_data *bo_data = NULL; tbm_backend_bufmgr_func *bufmgr_func = NULL; tbm_bufmgr_backend backend = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + bo_data = calloc(1, sizeof(struct _tbm_bo_data)); + if (!bo_data) { + TBM_ERR("memory allocation failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + } + switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error); + bo_data->hal_bo = hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error); + if (!bo_data->hal_bo) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL); + } break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -892,7 +961,11 @@ tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, t TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error); + bo_data->backend_bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error); + if (!bo_data->backend_bo_data) { + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL); + } break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -900,22 +973,54 @@ tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, t TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import, NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = (void *)backend->bo_import(bo, key); - if (!bo_data) + bo_data->priv = (void *)backend->bo_import(bo, key); + if (!bo_data->priv) { *error = TBM_ERROR_INVALID_OPERATION; - else + free(bo_data); + TBM_RETURN_VAL_IF_FAIL(bo_data->priv, NULL); + } else { *error = TBM_ERROR_NONE; + } break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + free(bo_data); break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; } +int +tbm_module_compare_bo_data(tbm_module *module, tbm_bo_data *bo_data1, tbm_bo_data *bo_data2) +{ + TBM_RETURN_VAL_IF_FAIL(module, 0); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + return (bo_data1->hal_bo == bo_data2->hal_bo); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + return (bo_data1->backend_bo_data == bo_data2->backend_bo_data); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + return (bo_data1->priv == bo_data2->priv); + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + break; +/* LCOV_EXCL_STOP */ + } + + return 0; +} + void tbm_surface_data_free(tbm_surface_data *surface_data) { @@ -945,10 +1050,12 @@ tbm_surface_data_get_plane_data(tbm_surface_data *surface_data, int plane_idx, u return TBM_ERROR_NONE; } -tbm_backend_bo_data ** +tbm_bo_data ** tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, tbm_error_e *error) { + tbm_bo_data **bo_data_array = NULL; hal_tbm_bo **hal_bos = NULL; + int i; TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data, NULL, *error, TBM_ERROR_INVALID_PARAMETER); TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data->hal_surface, NULL, *error, TBM_ERROR_NOT_SUPPORTED); @@ -956,7 +1063,19 @@ tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, hal_bos = hal_tbm_surface_get_bos(surface_data->hal_surface, num_bos, (hal_tbm_error *)error); TBM_RETURN_VAL_IF_FAIL(hal_bos, NULL); - return (tbm_backend_bo_data **)hal_bos; + bo_data_array = calloc(*num_bos, sizeof(struct _tbm_bo_data)); + if (bo_data_array) { + TBM_ERR("memory allocation failed."); + *error = TBM_ERROR_OUT_OF_MEMORY; + return NULL; + } + + for (i = 0; i < *num_bos; i++) { + bo_data_array[i]->hal_bo = hal_bos[i]; + bo_data_array[i]->module = surface_data->module; + } + + return bo_data_array; } tbm_surface_buffer_data * @@ -975,7 +1094,7 @@ tbm_surface_data_export(tbm_surface_data *surface_data, tbm_error_e *error) } void -tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int get_from_surface_data) +tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int get_from_surface_data) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -987,8 +1106,10 @@ tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api. - if (!get_from_surface_data) - hal_tbm_bo_free(bo_data); + if (!get_from_surface_data) { + hal_tbm_bo_free(bo_data->hal_bo); + bo_data->hal_bo = NULL; + } break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -996,7 +1117,8 @@ tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, TBM_RETURN_IF_FAIL(bo_func); TBM_RETURN_IF_FAIL(bo_func->bo_free); - bo_func->bo_free(bo_data); + bo_func->bo_free(bo_data->backend_bo_data); + bo_data->backend_bo_data = NULL; break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1004,17 +1126,21 @@ tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, TBM_RETURN_IF_FAIL(backend); TBM_RETURN_IF_FAIL(backend->bo_free); - backend->bo_free(bo); + backend->bo_free(bo_data->priv); + bo_data->priv = NULL; break; default: TBM_ERR("Wrong module type:%d", module->type); break; /* LCOV_EXCL_STOP */ } + + bo_data->module = NULL; + free(bo_data); } int -tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1024,7 +1150,7 @@ tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_da switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - size = hal_tbm_bo_get_size((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + size = hal_tbm_bo_get_size(bo_data->hal_bo, (hal_tbm_error *)error); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1032,7 +1158,7 @@ tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_da TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_size, 0, *error, TBM_ERROR_NOT_SUPPORTED); - size = bo_func->bo_get_size(bo_data, error); + size = bo_func->bo_get_size(bo_data->backend_bo_data, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1040,7 +1166,7 @@ tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_da TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_size, 0, *error, TBM_ERROR_NOT_SUPPORTED); - size = backend->bo_size(bo); + size = backend->bo_size(bo_data->priv); if (size == 0) *error = TBM_ERROR_INVALID_OPERATION; else @@ -1057,7 +1183,7 @@ tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_da } int -tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1067,7 +1193,7 @@ tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_dat switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types(bo_data->hal_bo, (hal_tbm_error *)error); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1075,7 +1201,7 @@ tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_dat TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_memory_types, 0, *error, TBM_ERROR_NOT_SUPPORTED); - memory_types = bo_func->bo_get_memory_types(bo_data, error); + memory_types = bo_func->bo_get_memory_types(bo_data->backend_bo_data, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1083,7 +1209,7 @@ tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_dat TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_flags, 0, *error, TBM_ERROR_NOT_SUPPORTED); - memory_types = backend->bo_get_flags(bo); + memory_types = backend->bo_get_flags(bo_data->priv); *error = TBM_ERROR_NONE; break; default: @@ -1097,7 +1223,7 @@ tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_dat } tbm_bo_handle -tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, tbm_error_e *error) +tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1108,7 +1234,7 @@ tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo_data, device, (hal_tbm_error *)error); + hbo_handle = hal_tbm_bo_get_handle(bo_data->hal_bo, device, (hal_tbm_error *)error); if (hbo_handle.ptr != NULL) memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); break; @@ -1118,7 +1244,7 @@ tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_handle = bo_func->bo_get_handle(bo_data, device, error); + bo_handle = bo_func->bo_get_handle(bo_data->backend_bo_data, device, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1126,7 +1252,7 @@ tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_handle = backend->bo_get_handle(bo, device); + bo_handle = backend->bo_get_handle(bo_data->priv, device); if (!bo_handle.ptr) *error = TBM_ERROR_INVALID_OPERATION; else @@ -1144,7 +1270,7 @@ tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ } tbm_bo_handle -tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt, tbm_error_e *error) +tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, int opt, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1155,7 +1281,7 @@ tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, i switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo_data, device, opt, (hal_tbm_error *)error); + hbo_handle = hal_tbm_bo_map(bo_data->hal_bo, device, opt, (hal_tbm_error *)error); if (hbo_handle.ptr != NULL) memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); break; @@ -1165,7 +1291,7 @@ tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, i TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_handle = bo_func->bo_map(bo_data, device, opt, error); + bo_handle = bo_func->bo_map(bo_data->backend_bo_data, device, opt, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1173,7 +1299,7 @@ tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, i TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); - bo_handle = backend->bo_map(bo, device, opt); + bo_handle = backend->bo_map(bo_data->priv, device, opt); if (!bo_handle.ptr) *error = TBM_ERROR_INVALID_OPERATION; else @@ -1191,7 +1317,7 @@ tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, i } tbm_error_e -tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) +tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1202,7 +1328,7 @@ tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo_data); + error = (hal_tbm_error)hal_tbm_bo_unmap(bo_data->hal_bo); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1210,7 +1336,7 @@ tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, TBM_ERROR_NOT_SUPPORTED); - error = bo_func->bo_unmap(bo->bo_data); + error = bo_func->bo_unmap(bo_data->backend_bo_data); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1218,7 +1344,7 @@ tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_IF_FAIL(backend->bo_unmap, TBM_ERROR_NOT_SUPPORTED); - ret = backend->bo_unmap(bo); + ret = backend->bo_unmap(bo_data->priv); if (!ret) error = TBM_ERROR_INVALID_OPERATION; else @@ -1235,7 +1361,7 @@ tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) } tbm_error_e -tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt) +tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, int opt) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1246,7 +1372,7 @@ tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo_data, device, opt); + error = (tbm_error_e)hal_tbm_bo_lock(bo_data->hal_bo, device, opt); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1255,7 +1381,7 @@ tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, if (!bo_func->bo_lock) return TBM_ERROR_NOT_SUPPORTED; - error = bo_func->bo_lock(bo_data, device, opt); + error = bo_func->bo_lock(bo_data->backend_bo_data, device, opt); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1264,7 +1390,7 @@ tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, if (!backend->bo_unmap) return TBM_ERROR_NOT_SUPPORTED; - ret = backend->bo_lock(bo, device, opt); + ret = backend->bo_lock(bo_data->priv, device, opt); if (!ret) error = TBM_ERROR_INVALID_OPERATION; else @@ -1281,7 +1407,7 @@ tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, } tbm_error_e -tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) +tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1291,7 +1417,7 @@ tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo_data); + error = (tbm_error_e)hal_tbm_bo_unlock(bo_data->hal_bo); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1300,7 +1426,7 @@ tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data if (!bo_func->bo_unlock) return TBM_ERROR_NOT_SUPPORTED; - error = bo_func->bo_unlock(bo->bo_data); + error = bo_func->bo_unlock(bo_data->backend_bo_data); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1309,7 +1435,7 @@ tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data if (!backend->bo_unlock) return TBM_ERROR_NOT_SUPPORTED; - backend->bo_unlock(bo); + backend->bo_unlock(bo_data->priv); error = TBM_ERROR_NONE; break; default: @@ -1323,7 +1449,7 @@ tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data } tbm_fd -tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1333,7 +1459,7 @@ tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_d switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - fd = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + fd = (hal_tbm_fd)hal_tbm_bo_export_fd(bo_data->hal_bo, (hal_tbm_error *)error); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1341,7 +1467,7 @@ tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_d TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, -1, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED); - fd = bo_func->bo_export_fd(bo_data, error); + fd = bo_func->bo_export_fd(bo_data->backend_bo_data, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1349,7 +1475,7 @@ tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_d TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, -1, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED); - fd = backend->bo_export_fd(bo); + fd = backend->bo_export_fd(bo_data->priv); if (fd < 0) *error = TBM_ERROR_INVALID_OPERATION; else @@ -1367,7 +1493,7 @@ tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_d } tbm_key -tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error) { tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; @@ -1377,7 +1503,7 @@ tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ switch (module->type) { case TBM_MODULE_TYPE_HAL_TBM: - ret = (hal_tbm_fd)hal_tbm_bo_export_key((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + ret = (hal_tbm_fd)hal_tbm_bo_export_key(bo_data->hal_bo, (hal_tbm_error *)error); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: @@ -1385,7 +1511,7 @@ tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_key, 0, *error, TBM_ERROR_NOT_SUPPORTED); - ret = bo_func->bo_export_key(bo_data, error); + ret = bo_func->bo_export_key(bo_data->backend_bo_data, error); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); @@ -1393,7 +1519,7 @@ tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_ TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export, 0, *error, TBM_ERROR_NOT_SUPPORTED); - ret = backend->bo_export(bo); + ret = backend->bo_export(bo_data->priv); if (!ret) *error = TBM_ERROR_INVALID_OPERATION; else diff --git a/src/tbm_module.h b/src/tbm_module.h index c831bd5..c8f163b 100644 --- a/src/tbm_module.h +++ b/src/tbm_module.h @@ -74,6 +74,13 @@ typedef struct _tbm_surface_data { hal_tbm_surface *hal_surface; } tbm_surface_data; +typedef struct _tbm_bo_data { + tbm_module *module; + hal_tbm_bo *hal_bo; + tbm_backend_bo_data *backend_bo_data; + void *priv; +} tbm_bo_data; + /* tbm_module functions */ tbm_module *tbm_module_load(int fd); void tbm_module_unload(tbm_module *module); @@ -87,25 +94,26 @@ int tbm_module_support_surface_data(tbm_module *module); tbm_surface_data *tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int format, int flags, tbm_error_e *error); tbm_surface_data *tbm_module_import_surface_data(tbm_module *module, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error); -tbm_backend_bo_data *tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error); -tbm_backend_bo_data *tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width, int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error); -tbm_backend_bo_data *tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error); -tbm_backend_bo_data *tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error); +tbm_bo_data *tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error); +tbm_bo_data *tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width, int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error); +tbm_bo_data *tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error); +tbm_bo_data *tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error); +int tbm_module_compare_bo_data(tbm_module *module, tbm_bo_data *bo_data1, tbm_bo_data *bo_data2); void tbm_surface_data_free(tbm_surface_data *surface_data); tbm_error_e tbm_surface_data_get_plane_data(tbm_surface_data *surface_data, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx); -tbm_backend_bo_data **tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, tbm_error_e *error); +tbm_bo_data **tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, tbm_error_e *error); tbm_surface_buffer_data *tbm_surface_data_export(tbm_surface_data *surface_data, tbm_error_e *error); -void tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int get_from_surface_data); -int tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error); -int tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error); -tbm_bo_handle tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, tbm_error_e *error); -tbm_bo_handle tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt, tbm_error_e *error); -tbm_error_e tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data); -tbm_error_e tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt); -tbm_error_e tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data); -tbm_fd tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error); -tbm_key tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error); +void tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int get_from_surface_data); +int tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error); +int tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error); +tbm_bo_handle tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, tbm_error_e *error); +tbm_bo_handle tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, int opt, tbm_error_e *error); +tbm_error_e tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data); +tbm_error_e tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, int device, int opt); +tbm_error_e tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data); +tbm_fd tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error); +tbm_key tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_bo_data *bo_data, tbm_error_e *error); #endif // _TBM_MODULE_H_ diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c index 90e4758..6e6a492 100644 --- a/src/tbm_surface_internal.c +++ b/src/tbm_surface_internal.c @@ -699,7 +699,7 @@ _tbm_surface_internal_create_surface_data(tbm_bufmgr bufmgr, int width, int heig struct _tbm_surface *surf = NULL; uint32_t size = 0, offset = 0, stride = 0; int i, j, bo_idx; - tbm_backend_bo_data **bo_data_array = NULL; + tbm_bo_data **bo_data_array = NULL; int num_bos = 0; surf = calloc(1, sizeof(struct _tbm_surface)); @@ -806,7 +806,7 @@ _tbm_surface_internal_import_surface_data(tbm_bufmgr bufmgr, int width, int heig struct _tbm_surface *surf = NULL; uint32_t size = 0, offset = 0, stride = 0; int i, j, bo_idx; - tbm_backend_bo_data **bo_data_array = NULL; + tbm_bo_data **bo_data_array = NULL; int num_bos = 0; int flags; -- 2.7.4