From b25993af44337f3f71d5c086fdb0760fcc1b6e38 Mon Sep 17 00:00:00 2001 From: Junkyeong Kim Date: Thu, 4 Feb 2021 13:51:27 +0900 Subject: [PATCH] adapt hal-api-tbm libtbm uses hal-api-tbm from Tizen 6.5. Therefore, libtbm links libhal-api-tbm library and libtbm work with hal-api-tbm when the hal-backend-tbm backend library at /hal/lib directory. If not, libtbm works with the legacy tbm backend so file at /usr/lib/bufmgr directory. Change-Id: I6428b3cddf8914f38c4b2ca55b5f731440846e2f Signed-off-by: Junkyeong Kim --- configure.ac | 7 +- include/tbm_type_common.h | 0 packaging/libtbm.spec | 1 + src/tbm_bo.c | 390 ++++++++++++++++++++++++++++++++------------- src/tbm_bufmgr.c | 125 ++++++++++++--- src/tbm_bufmgr_int.h | 5 + src/tbm_surface_internal.c | 54 ++++++- 7 files changed, 445 insertions(+), 137 deletions(-) mode change 100755 => 100644 include/tbm_type_common.h diff --git a/configure.ac b/configure.ac index 9c3ac2f..4016e6c 100644 --- a/configure.ac +++ b/configure.ac @@ -75,6 +75,7 @@ if test x"$capi_0_1_1" = xyes; then AC_DEFINE(HAVE_CAPI_0_1_1,1,[The version of capi-base-common is over 0.1.1]) fi +PKG_CHECK_MODULES(HAL_API_TBM, hal-api-tbm) PKG_CHECK_MODULES(LIBDRM, libdrm) PKG_CHECK_MODULES(WL_CLIENT, wayland-client) PKG_CHECK_MODULES(WL_SERVER, wayland-server) @@ -83,10 +84,10 @@ PKG_CHECK_MODULES(LIBPNG, libpng) PKG_CHECK_MODULES(LIBPIXMAN, pixman-1) PKG_CHECK_MODULES(GMOCK, gmock) -LIBTBM_CFLAGS+="$LIBTBM_CFALGS $LIBDRM_CFLAGS $CAPI_CFLAGS $WL_CLIENT_CFLAGS $WL_SERVER_CFLAGS $LIBPNG_CFLAGS $LIBPIXMAN_CFLAGS " -LIBTBM_LIBS+="$LIBTBM_LIBS $LIBDRM_LIBS $CAPI_LIBS $WL_CLIENT_LIBS $WL_SERVER_LIBS $LIBPNG_LIBS $LIBPIXMAN_LIBS " +LIBTBM_CFLAGS+="$LIBTBM_CFALGS $HAL_API_TBM_CFLAGS $LIBDRM_CFLAGS $CAPI_CFLAGS $WL_CLIENT_CFLAGS $WL_SERVER_CFLAGS $LIBPNG_CFLAGS $LIBPIXMAN_CFLAGS " +LIBTBM_LIBS+="$LIBTBM_LIBS $HAL_API_TBM_LIBS $LIBDRM_LIBS $CAPI_LIBS $WL_CLIENT_LIBS $WL_SERVER_LIBS $LIBPNG_LIBS $LIBPIXMAN_LIBS " -LIBTBM_TEST_CFLAGS="$GMOCK_CLAGS" +LIBTBM_TEST_CFLAGS="$GMOCK_CFLAGS" LIBTBM_TEST_LIBS="$GMOCK_LIBS" PKG_CHECK_EXISTS([dlog], [have_dlog="yes"], [have_dlog="no"]) diff --git a/include/tbm_type_common.h b/include/tbm_type_common.h old mode 100755 new mode 100644 diff --git a/packaging/libtbm.spec b/packaging/libtbm.spec index 4f967b8..06506d9 100644 --- a/packaging/libtbm.spec +++ b/packaging/libtbm.spec @@ -27,6 +27,7 @@ BuildRequires: pkgconfig(libpng) BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(pixman-1) BuildRequires: pkgconfig(gmock) +BuildRequires: pkgconfig(hal-api-tbm) %description Description: %{summary} diff --git a/src/tbm_bo.c b/src/tbm_bo.c index b6d9d2e..35deb2c 100644 --- a/src/tbm_bo.c +++ b/src/tbm_bo.c @@ -155,7 +155,14 @@ _bo_lock(tbm_bo bo, int device, int opt) int ret = 1; tbm_error_e error; - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo->bo_data, device, opt); + if (error != TBM_ERROR_NONE) { + TBM_WRN("fail to lock"); + _tbm_set_last_result(error); + ret = 0; + } + } else if (bo->bufmgr->backend_module_data) { if (bo->bufmgr->bo_func->bo_lock) { error = bo->bufmgr->bo_func->bo_lock(bo->bo_data, device, opt); if (error != TBM_ERROR_NONE) { @@ -180,7 +187,13 @@ _bo_unlock(tbm_bo bo) { tbm_error_e error; - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo->bo_data); + if (error != TBM_ERROR_NONE) { + TBM_WRN("fail to lock"); + _tbm_set_last_result(error); + } + } else if (bo->bufmgr->backend_module_data) { if (bo->bufmgr->bo_func->bo_unlock) { error = bo->bufmgr->bo_func->bo_unlock(bo->bo_data); if (error != TBM_ERROR_NONE) { @@ -346,8 +359,6 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) bo = calloc(1, sizeof(struct _tbm_bo)); if (!bo) { /* LCOV_EXCL_START */ - TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", - size, _tbm_flag_to_str(flags)); _tbm_set_last_result(TBM_ERROR_OUT_OF_MEMORY); _tbm_bufmgr_mutex_unlock(); return NULL; @@ -356,16 +367,21 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) _tbm_util_check_bo_cnt(bufmgr); - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(bufmgr->hal_bufmgr, size, flags, (hal_tbm_error *)&error); + /* LCOV_EXCL_START */ + if (!bo_data) { + _tbm_set_last_result(error); + goto alloc_fail; + } + /* LCOV_EXCL_STOP */ + bo->bo_data = bo_data; + } else if (bufmgr->backend_module_data) { bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo(bufmgr->bufmgr_data, (unsigned int)size, flags, &error); if (!bo_data) { /* LCOV_EXCL_START */ - TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", - size, _tbm_flag_to_str(flags)); _tbm_set_last_result(error); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto alloc_fail; /* LCOV_EXCL_STOP */ } bo->bo_data = bo_data; @@ -373,12 +389,9 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) bo_priv = bufmgr->backend->bo_alloc(bo, size, flags); if (!bo_priv) { /* LCOV_EXCL_START */ - TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", - size, _tbm_flag_to_str(flags)); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto alloc_fail; /* LCOV_EXCL_STOP */ } bo->priv = bo_priv; @@ -392,6 +405,12 @@ tbm_bo_alloc(tbm_bufmgr bufmgr, int size, int flags) _tbm_bufmgr_mutex_unlock(); return bo; + +alloc_fail: + TBM_ERR("error: fail to create of tbm_bo size(%d) flag(%s)\n", size, _tbm_flag_to_str(flags)); + free(bo); + _tbm_bufmgr_mutex_unlock(); + return NULL; } /* LCOV_EXCL_START */ @@ -418,17 +437,24 @@ tbm_bo_alloc_with_format(tbm_bufmgr bufmgr, int format, int bo_idx, int width, _tbm_util_check_bo_cnt(bufmgr); - if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) { - /* LCOV_EXCL_START */ - TBM_ERR("error: not supported tbm_bo_alloc_with_format\n"); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; - /* LCOV_EXCL_STOP */ + /* LCOV_EXCL_START */ + if (!bufmgr->use_hal_tbm) { + if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format) { + + TBM_ERR("error: not supported tbm_bo_alloc_with_format\n"); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + free(bo); + _tbm_bufmgr_mutex_unlock(); + return NULL; + } } + /* LCOV_EXCL_STOP */ - bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format(bufmgr->bufmgr_data, format, bo_idx, + if (bufmgr->use_hal_tbm) + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(bufmgr->hal_bufmgr, + format, bo_idx, width, height, (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error); + else + bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format(bufmgr->bufmgr_data, format, bo_idx, width, height, flags, error); if (!bo_data) { TBM_ERR("error: fail to tbm_bo_alloc_with_format fmt(%s) idx(%d) w(%d) h(%d) mem_types(%s)\n", @@ -470,15 +496,21 @@ tbm_bo_alloc_with_tiled_format(tbm_bufmgr bufmgr, int width, int height, int bpp _tbm_util_check_bo_cnt(bufmgr); - if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format) { - TBM_ERR("error: not supported tbm_bo_alloc_with_tiled_format\n"); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + if (!bufmgr->use_hal_tbm) { + if (!bufmgr->backend_module_data || !bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format) { + TBM_ERR("error: not supported tbm_bo_alloc_with_tiled_format\n"); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + free(bo); + _tbm_bufmgr_mutex_unlock(); + return NULL; + } } - bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format(bufmgr->bufmgr_data, width, height, + if (bufmgr->use_hal_tbm) + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_tiled_format(bufmgr->hal_bufmgr, + width, height, bpp, format, (hal_tbm_bo_memory_type)flags, bo_idx, (hal_tbm_error *)error); + else + bo_data = bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format(bufmgr->bufmgr_data, width, height, bpp, format, flags, bo_idx, error); if (!bo_data) { TBM_ERR("error: fail to tbm_bo_alloc_with_tiled_format fmt(%s) idx(%d) w(%d) h(%d) flags(%s)\n", @@ -602,15 +634,24 @@ tbm_bo_map(tbm_bo bo, int device, int opt) return (tbm_bo_handle) NULL; } - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + hal_tbm_bo_handle hbo_handle; + hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo->bo_data, device, opt, (hal_tbm_error *)&error); + if (hbo_handle.ptr == NULL) { + /* LCOV_EXCL_START */ + _tbm_set_last_result(error); + TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error); + goto bo_map_fail; + /* LCOV_EXCL_STOP */ + } + memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); + } else if (bo->bufmgr->backend_module_data) { bo_handle = bo->bufmgr->bo_func->bo_map(bo->bo_data, device, opt, &error); if (bo_handle.ptr == NULL) { /* LCOV_EXCL_START */ _tbm_set_last_result(error); TBM_ERR("error: fail to map bo:%p error:%d\n", bo, error); - _tbm_bo_unlock(bo); - _tbm_bufmgr_mutex_unlock(); - return (tbm_bo_handle) NULL; + goto bo_map_fail; /* LCOV_EXCL_STOP */ } } else { @@ -619,9 +660,7 @@ tbm_bo_map(tbm_bo bo, int device, int opt) /* LCOV_EXCL_START */ _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); TBM_ERR("error: fail to map bo:%p\n", bo); - _tbm_bo_unlock(bo); - _tbm_bufmgr_mutex_unlock(); - return (tbm_bo_handle) NULL; + goto bo_map_fail; /* LCOV_EXCL_STOP */ } } @@ -634,6 +673,11 @@ tbm_bo_map(tbm_bo bo, int device, int opt) _tbm_bufmgr_mutex_unlock(); return bo_handle; + +bo_map_fail: + _tbm_bo_unlock(bo); + _tbm_bufmgr_mutex_unlock(); + return (tbm_bo_handle) NULL; } int @@ -648,15 +692,24 @@ tbm_bo_unmap(tbm_bo bo) TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); TBM_BO_RETURN_VAL_IF_FAIL(bo->map_cnt > 0, 0); - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo->bo_data); + if (error != TBM_ERROR_NONE) { + /* LCOV_EXCL_START */ + TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error); + _tbm_set_last_result(error); + ret = 0; + goto done; + /* LCOV_EXCL_STOP */ + } + } else if (bo->bufmgr->backend_module_data) { error = bo->bufmgr->bo_func->bo_unmap(bo->bo_data); if (error != TBM_ERROR_NONE) { /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) map_cnt(%d) error(%d)\n", bo, bo->map_cnt, error); _tbm_set_last_result(error); ret = 0; - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } else { @@ -665,8 +718,7 @@ tbm_bo_unmap(tbm_bo bo) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) map_cnt(%d)\n", bo, bo->map_cnt); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } @@ -678,6 +730,7 @@ tbm_bo_unmap(tbm_bo bo) _tbm_bo_unlock(bo); +done: _tbm_bufmgr_mutex_unlock(); return ret; @@ -694,14 +747,24 @@ tbm_bo_get_handle(tbm_bo bo, int device) TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), (tbm_bo_handle) NULL); - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + hal_tbm_bo_handle hbo_handle; + hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo->bo_data, device, (hal_tbm_error *)&error); + if (hbo_handle.ptr == NULL) { + /* LCOV_EXCL_START */ + TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, hbo_handle.ptr, error); + _tbm_set_last_result(error); + goto bo_handle_fail; + /* LCOV_EXCL_STOP */ + } + memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); + } else if (bo->bufmgr->backend_module_data) { bo_handle = bo->bufmgr->bo_func->bo_get_handle(bo->bo_data, device, &error); if (bo_handle.ptr == NULL) { /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) bo_handle(%p) error(%d)\n", bo, bo_handle.ptr, error); _tbm_set_last_result(error); - _tbm_bufmgr_mutex_unlock(); - return (tbm_bo_handle) NULL; + goto bo_handle_fail; /* LCOV_EXCL_STOP */ } } else { @@ -710,8 +773,7 @@ tbm_bo_get_handle(tbm_bo bo, int device) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) bo_handle(%p)\n", bo, bo_handle.ptr); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - _tbm_bufmgr_mutex_unlock(); - return (tbm_bo_handle) NULL; + goto bo_handle_fail; /* LCOV_EXCL_STOP */ } } @@ -721,6 +783,10 @@ tbm_bo_get_handle(tbm_bo bo, int device) _tbm_bufmgr_mutex_unlock(); return bo_handle; + +bo_handle_fail: + _tbm_bufmgr_mutex_unlock(); + return (tbm_bo_handle) NULL; } tbm_key @@ -734,7 +800,16 @@ tbm_bo_export(tbm_bo bo) TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + ret = (hal_tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (!ret) { + /* LCOV_EXCL_START */ + TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error); + _tbm_set_last_result(error); + goto done; + /* LCOV_EXCL_STOP */ + } + } else if (bo->bufmgr->backend_module_data) { if (!bo->bufmgr->bo_func->bo_export_key) { /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); @@ -748,8 +823,7 @@ tbm_bo_export(tbm_bo bo) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) tbm_key(%d) error(%d)\n", bo, ret, error); _tbm_set_last_result(error); - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } else { @@ -766,14 +840,14 @@ tbm_bo_export(tbm_bo bo) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) tbm_key(%d)\n", bo, ret); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } TBM_TRACE_BO("bo(%p) tbm_key(%u)\n", bo, ret); +done: _tbm_bufmgr_mutex_unlock(); return ret; @@ -790,7 +864,16 @@ tbm_bo_export_fd(tbm_bo bo) TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), -1); - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + ret = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (ret < 0) { + /* LCOV_EXCL_START */ + TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error); + _tbm_set_last_result(error); + goto done; + /* LCOV_EXCL_STOP */ + } + } else if (bo->bufmgr->backend_module_data) { if (!bo->bufmgr->bo_func->bo_export_fd) { /* LCOV_EXCL_START */ _tbm_bufmgr_mutex_unlock(); @@ -804,8 +887,7 @@ tbm_bo_export_fd(tbm_bo bo) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) tbm_fd(%d) error(%d)\n", bo, ret, error); _tbm_set_last_result(error); - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } else { @@ -822,14 +904,14 @@ tbm_bo_export_fd(tbm_bo bo) /* LCOV_EXCL_START */ TBM_ERR("error: bo(%p) tbm_fd(%d)\n", bo, ret); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - _tbm_bufmgr_mutex_unlock(); - return ret; + goto done; /* LCOV_EXCL_STOP */ } } TBM_TRACE_BO("bo(%p) tbm_fd(%d)\n", bo, ret); +done: _tbm_bufmgr_mutex_unlock(); return ret; @@ -850,21 +932,23 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL); - if (bufmgr->backend_module_data) { - if (!bufmgr->bufmgr_func->bufmgr_import_key) { - /* LCOV_EXCL_START */ - _tbm_bufmgr_mutex_unlock(); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - return NULL; - /* LCOV_EXCL_STOP */ - } - } else { - if (!bufmgr->backend->bo_import) { - /* LCOV_EXCL_START */ - _tbm_bufmgr_mutex_unlock(); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - return NULL; - /* LCOV_EXCL_STOP */ + if (!bufmgr->use_hal_tbm) { + if (bufmgr->backend_module_data) { + if (!bufmgr->bufmgr_func->bufmgr_import_key) { + /* LCOV_EXCL_START */ + _tbm_bufmgr_mutex_unlock(); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + return NULL; + /* LCOV_EXCL_STOP */ + } + } else { + if (!bufmgr->backend->bo_import) { + /* LCOV_EXCL_START */ + _tbm_bufmgr_mutex_unlock(); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + return NULL; + /* LCOV_EXCL_STOP */ + } } } @@ -880,15 +964,36 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) /* LCOV_EXCL_STOP */ } - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(bufmgr->hal_bufmgr, key, (hal_tbm_error *)&error); + /* LCOV_EXCL_START */ + if (!bo_data) { + TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error); + _tbm_set_last_result(error); + goto import_fail; + } + /* LCOV_EXCL_STOP */ + if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { + LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { + if (bo2->bo_data == bo_data) { + TBM_TRACE_BO("find bo(%p) ref(%d) key(%d) flag(%s) in list\n", + bo2, bo2->ref_cnt, key, + _tbm_flag_to_str(bo2->flags)); + bo2->ref_cnt++; + free(bo); + _tbm_bufmgr_mutex_unlock(); + return bo2; + } + } + } + bo->bo_data = bo_data; + } else if (bufmgr->backend_module_data) { bo_data = bufmgr->bufmgr_func->bufmgr_import_key(bufmgr->bufmgr_data, key, &error); if (!bo_data) { /* LCOV_EXCL_START */ TBM_ERR("error: fail to import of tbm_bo by key(%d). error(%d)\n", key, error); _tbm_set_last_result(error); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto import_fail; /* LCOV_EXCL_STOP */ } @@ -912,9 +1017,7 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) /* LCOV_EXCL_START */ TBM_ERR("error: fail to import of tbm_bo by key(%d)\n", key); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto import_fail; /* LCOV_EXCL_STOP */ } @@ -934,7 +1037,14 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) bo->priv = bo_priv; } - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + _tbm_set_last_result(error); + flags = TBM_BO_DEFAULT; + } + } else if (bufmgr->backend_module_data) { flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error); if (error != TBM_ERROR_NONE) { TBM_ERR("fail to get the bo flags(memory_types)"); @@ -956,6 +1066,11 @@ tbm_bo_import(tbm_bufmgr bufmgr, unsigned int key) _tbm_bufmgr_mutex_unlock(); return bo; + +import_fail: + free(bo); + _tbm_bufmgr_mutex_unlock(); + return NULL; } tbm_bo @@ -973,21 +1088,23 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) TBM_BO_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(bufmgr), NULL); - if (bufmgr->backend_module_data) { - if (!bufmgr->bufmgr_func->bufmgr_import_fd) { - /* LCOV_EXCL_START */ - _tbm_bufmgr_mutex_unlock(); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - return NULL; - /* LCOV_EXCL_STOP */ - } - } else { - if (!bufmgr->backend->bo_import_fd) { - /* LCOV_EXCL_START */ - _tbm_bufmgr_mutex_unlock(); - _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); - return NULL; - /* LCOV_EXCL_STOP */ + if (!bufmgr->use_hal_tbm) { + if (bufmgr->backend_module_data) { + if (!bufmgr->bufmgr_func->bufmgr_import_fd) { + /* LCOV_EXCL_START */ + _tbm_bufmgr_mutex_unlock(); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + return NULL; + /* LCOV_EXCL_STOP */ + } + } else { + if (!bufmgr->backend->bo_import_fd) { + /* LCOV_EXCL_START */ + _tbm_bufmgr_mutex_unlock(); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + return NULL; + /* LCOV_EXCL_STOP */ + } } } @@ -1003,15 +1120,36 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) /* LCOV_EXCL_STOP */ } - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(bufmgr->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)&error); + /* LCOV_EXCL_START */ + if (!bo_data) { + TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error); + _tbm_set_last_result(error); + goto import_fail; + } + /* LCOV_EXCL_STOP */ + + if (!LIST_IS_EMPTY(&bufmgr->bo_list)) { + LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { + if (bo2->bo_data == bo_data) { + TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n", + bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags)); + bo2->ref_cnt++; + free(bo); + _tbm_bufmgr_mutex_unlock(); + return bo2; + } + } + } + bo->bo_data = bo_data; + } else if (bufmgr->backend_module_data) { bo_data = bufmgr->bufmgr_func->bufmgr_import_fd(bufmgr->bufmgr_data, fd, &error); if (!bo_data) { /* LCOV_EXCL_START */ TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d). error(%d)\n", fd, error); _tbm_set_last_result(error); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto import_fail; /* LCOV_EXCL_STOP */ } @@ -1019,8 +1157,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { if (bo2->bo_data == bo_data) { TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n", - bo2, bo2->ref_cnt, fd, - _tbm_flag_to_str(bo2->flags)); + bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags)); bo2->ref_cnt++; free(bo); _tbm_bufmgr_mutex_unlock(); @@ -1035,9 +1172,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) /* LCOV_EXCL_START */ TBM_ERR("error: fail to import tbm_bo by tbm_fd(%d)\n", fd); _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); - free(bo); - _tbm_bufmgr_mutex_unlock(); - return NULL; + goto import_fail; /* LCOV_EXCL_STOP */ } @@ -1045,8 +1180,7 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) LIST_FOR_EACH_ENTRY(bo2, &bufmgr->bo_list, item_link) { if (bo2->priv == bo_priv) { TBM_TRACE_BO("find bo(%p) ref(%d) fd(%d) flag(%s) in list\n", - bo2, bo2->ref_cnt, fd, - _tbm_flag_to_str(bo2->flags)); + bo2, bo2->ref_cnt, fd, _tbm_flag_to_str(bo2->flags)); bo2->ref_cnt++; free(bo); _tbm_bufmgr_mutex_unlock(); @@ -1057,7 +1191,14 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) bo->priv = bo_priv; } - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + flags = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the bo flags(memory_types)"); + _tbm_set_last_result(error); + flags = TBM_BO_DEFAULT; + } + } else if (bufmgr->backend_module_data) { flags = bufmgr->bo_func->bo_get_memory_types(bo->bo_data, &error); if (error != TBM_ERROR_NONE) { TBM_ERR("fail to get the bo flags(memory_types)"); @@ -1079,6 +1220,11 @@ tbm_bo_import_fd(tbm_bufmgr bufmgr, tbm_fd fd) _tbm_bufmgr_mutex_unlock(); return bo; + +import_fail: + free(bo); + _tbm_bufmgr_mutex_unlock(); + return NULL; } int @@ -1092,7 +1238,13 @@ tbm_bo_size(tbm_bo bo) TBM_BO_RETURN_VAL_IF_FAIL(_tbm_bo_is_valid(bo), 0); - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) { + TBM_ERR("fail to get the size of the bo_data(%d).", error); + _tbm_set_last_result(TBM_ERROR_NONE); + } + } else if (bo->bufmgr->backend_module_data) { size = bo->bufmgr->bo_func->bo_get_size(bo->bo_data, &error); if (error != TBM_ERROR_NONE) { TBM_ERR("fail to get the size of the bo_data(%d).", error); @@ -1150,7 +1302,20 @@ tbm_bo_swap(tbm_bo bo1, tbm_bo bo2) TBM_TRACE_BO("before: bo1(%p) bo2(%p)\n", bo1, bo2); - if (bo1->bufmgr->backend_module_data) { + if (bo1->bufmgr->use_hal_tbm) { + size1 = hal_tbm_bo_get_size((hal_tbm_bo *)bo1->bo_data, (hal_tbm_error *)&error1); + if (error1 != TBM_ERROR_NONE) { + TBM_ERR("fail to get the size of bo1.(%d)", error1); + _tbm_set_last_result(error1); + goto fail; + } + size2 = hal_tbm_bo_get_size((hal_tbm_bo *)bo2->bo_data, (hal_tbm_error *)&error2); + if (error2 != TBM_ERROR_NONE) { + TBM_ERR("fail to get the size of bo1.(%d)", error2); + _tbm_set_last_result(error2); + goto fail; + } + } else if (bo1->bufmgr->backend_module_data) { size1 = bo1->bufmgr->bo_func->bo_get_size(bo1->bo_data, &error1); if (error1 != TBM_ERROR_NONE) { TBM_ERR("fail to get the size of bo1.(%d)", error1); @@ -1388,7 +1553,10 @@ _tbm_bo_free(tbm_bo bo) } /* call the bo_free */ - if (bo->bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + hal_tbm_bo_free(bo->bo_data); + bo->bo_data = NULL; + } else if (bo->bufmgr->backend_module_data) { bo->bufmgr->bo_func->bo_free(bo->bo_data); bo->bo_data = NULL; } else { diff --git a/src/tbm_bufmgr.c b/src/tbm_bufmgr.c index 6215836..c9872df 100644 --- a/src/tbm_bufmgr.c +++ b/src/tbm_bufmgr.c @@ -185,6 +185,58 @@ _tbm_util_get_appname_from_pid(long pid, char *str) } static int +_tbm_backend_load_hal_tbm(tbm_bufmgr bufmgr) +{ + hal_tbm_backend *hal_backend = NULL; + hal_tbm_bufmgr_capability capability; + hal_tbm_bufmgr *hal_bufmgr; + hal_tbm_error ret = HAL_TBM_ERROR_NONE; + + hal_backend = hal_tbm_get_backend(&ret); + if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("get backend fail"); + return 0; + } + + hal_bufmgr = hal_tbm_backend_get_bufmgr(hal_backend, &ret); + if (hal_bufmgr == NULL || ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("get hal_bufmgr fail"); + goto get_backend_fail; + } + + capability = hal_tbm_bufmgr_get_capabilities(hal_bufmgr, &ret); + if (ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("hal_tbm_bufmgr_get_capabilities fail."); + goto get_backend_fail; + } + + if (capability == HAL_TBM_BUFMGR_CAPABILITY_NONE) { + TBM_ERR("The capabilities of the backend module is TBM_BUFMGR_CAPABILITY_NONE."); + TBM_ERR("TBM_BUFMGR_CAPABILITY_SHARE_FD is the essential capability."); + goto get_backend_fail; + } + if (!(capability & HAL_TBM_BUFMGR_CAPABILITY_SHARE_FD)) { + TBM_ERR("The capabilities of the backend module had no TBM_BUFMGR_CAPABILITY_SHARE_FD."); + TBM_ERR("The tbm backend has to get TBM_BUFMGR_CAPABILITY_SHARE_FD. "); + goto get_backend_fail; + } + bufmgr->capabilities = capability; + + bufmgr->hal_backend = hal_backend; + bufmgr->hal_bufmgr = hal_bufmgr; + + bufmgr->use_hal_tbm = 1; + + TBM_INFO("use hal tbm"); + + return 1; + +get_backend_fail: + hal_tbm_put_backend(hal_backend); + return 0; +} + +static int _check_version(TBMModuleVersionInfo *data) { int backend_module_major, backend_module_minor; @@ -427,6 +479,11 @@ _tbm_load_module(tbm_bufmgr bufmgr, int fd) struct dirent **namelist; int ret = 0, n; + /* try to load the hal-tbm backend module */ + ret = _tbm_backend_load_hal_tbm(bufmgr); + if (ret) + return 1; + /* try to load the new backend module */ ret = _tbm_backend_load_module(bufmgr, DEFAULT_LIB); if (ret) @@ -636,28 +693,34 @@ tbm_bufmgr_deinit(tbm_bufmgr bufmgr) LIST_DELINIT(&bufmgr->surf_list); } - if (bufmgr->backend_module_data) { - /* deinit and backend destroys the backend func and data */ - bufmgr->backend_module_data->deinit(bufmgr->bufmgr_data); - bufmgr->bo_func = NULL; - bufmgr->bufmgr_func = NULL; - bufmgr->bufmgr_data = NULL; - bufmgr->backend_module_data = NULL; + if (bufmgr->use_hal_tbm) { + hal_tbm_put_backend(bufmgr->hal_backend); + bufmgr->hal_backend = NULL; + bufmgr->hal_bufmgr = NULL; + bufmgr->use_hal_tbm = 0; } else { - /* destroy bufmgr priv */ - bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv); - bufmgr->backend->priv = NULL; - tbm_backend_free(bufmgr->backend); - bufmgr->backend = NULL; - } - - TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr); - - dlclose(bufmgr->module_data); + if (bufmgr->backend_module_data) { + /* deinit and backend destroys the backend func and data */ + bufmgr->backend_module_data->deinit(bufmgr->bufmgr_data); + bufmgr->bo_func = NULL; + bufmgr->bufmgr_func = NULL; + bufmgr->bufmgr_data = NULL; + bufmgr->backend_module_data = NULL; + } else { + /* destroy bufmgr priv */ + bufmgr->backend->bufmgr_deinit(bufmgr->backend->priv); + bufmgr->backend->priv = NULL; + tbm_backend_free(bufmgr->backend); + bufmgr->backend = NULL; + } + dlclose(bufmgr->module_data); + } if (bufmgr->fd > 0) close(bufmgr->fd); + TBM_INFO("destroy tbm_bufmgr(%p)\n", bufmgr); + free(bufmgr); gBufMgr = NULL; @@ -787,7 +850,11 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) TBM_SNRPRINTF(str, len, c, "%s\n", data); for (i = 0; i < surf->num_bos; i++) { - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + size = hal_tbm_bo_get_size((hal_tbm_bo *)surf->bos[i]->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) + TBM_WRN("fail to get the size of bo."); + } else if (bufmgr->backend_module_data) { size = bufmgr->bo_func->bo_get_size(surf->bos[i]->bo_data, &error); if (error != TBM_ERROR_NONE) TBM_WRN("fail to get the size of bo."); @@ -813,7 +880,12 @@ tbm_bufmgr_debug_tbm_info_get(tbm_bufmgr bufmgr) tbm_key key = 0; LIST_FOR_EACH_ENTRY(bo, &bufmgr->bo_list, item_link) { - if (bufmgr->backend_module_data) { + if (bo->bufmgr->use_hal_tbm) { + size = hal_tbm_bo_get_size((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + if (error != TBM_ERROR_NONE) + TBM_WRN("fail to get the size of bo."); + key = (tbm_key)hal_tbm_bo_export_key((hal_tbm_bo *)bo->bo_data, (hal_tbm_error *)&error); + } else if (bufmgr->backend_module_data) { size = bufmgr->bo_func->bo_get_size(bo->bo_data, &error); if (error != TBM_ERROR_NONE) TBM_WRN("fail to get the size of bo."); @@ -1031,7 +1103,20 @@ tbm_bufmgr_bind_native_display(tbm_bufmgr bufmgr, void *native_display) TBM_BUFMGR_RETURN_VAL_IF_FAIL(TBM_BUFMGR_IS_VALID(gBufMgr), 0); - if (bufmgr->backend_module_data) { + if (bufmgr->use_hal_tbm) { + error = (tbm_error_e)hal_tbm_bufmgr_bind_native_display(bufmgr->hal_bufmgr, (hal_tbm_native_display *)native_display); + if (error == TBM_ERROR_NOT_SUPPORTED) { + TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display); + _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); + _tbm_bufmgr_mutex_unlock(); + return 1; + } else if (error != TBM_ERROR_NONE) { + TBM_ERR("error: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display); + _tbm_set_last_result(TBM_ERROR_INVALID_OPERATION); + _tbm_bufmgr_mutex_unlock(); + return 0; + } + } else if (bufmgr->backend_module_data) { if (!bufmgr->bufmgr_func->bufmgr_bind_native_display) { TBM_WRN("skip: tbm_bufmgr(%p) native_display(%p)\n", bufmgr, native_display); diff --git a/src/tbm_bufmgr_int.h b/src/tbm_bufmgr_int.h index 7972b97..9df1dd7 100644 --- a/src/tbm_bufmgr_int.h +++ b/src/tbm_bufmgr_int.h @@ -58,6 +58,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include #include +#include extern tbm_bufmgr gBufMgr; extern int b_dump_queue; @@ -210,6 +211,10 @@ struct _tbm_bufmgr { tbm_backend_bufmgr_data *bufmgr_data; /* backend data of the backend module */ tbm_backend_bufmgr_func *bufmgr_func; /* backend functions for bufmgr */ tbm_backend_bo_func *bo_func; /* backend functions for bo */ + + int use_hal_tbm; /* use hal-api-tbm */ + hal_tbm_backend *hal_backend; /* hal-api-tbm backend */ + hal_tbm_bufmgr *hal_bufmgr; /* hal-api-tbm bufmgr */ }; /** diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c index 872fb5c..0e6f1f5 100644 --- a/src/tbm_surface_internal.c +++ b/src/tbm_surface_internal.c @@ -289,7 +289,21 @@ _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->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; @@ -610,7 +624,18 @@ tbm_surface_internal_query_supported_formats(uint32_t **formats, bufmgr = g_surface_bufmgr; - if (bufmgr->backend_module_data) { + 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 */ + } else if (bufmgr->backend_module_data) { if (!bufmgr->bufmgr_func->bufmgr_get_supported_formats) { _tbm_set_last_result(TBM_ERROR_NOT_SUPPORTED); goto fail; @@ -800,7 +825,30 @@ tbm_surface_internal_create_with_flags(int width, int height, 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 */ surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, flags, &error); -- 2.7.4