X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_module.c;h=16beb7f01911c6cf785f7cc694060a607711a8b1;hb=5d6f1d8855f0301ac781a5e66068344ed636a0b0;hp=7b2fb74dae3c3ae2c55dca011edcfa2931cdffe8;hpb=5f25ce45afee4aca55176bc4411a6f0bdc793848;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_module.c b/src/tbm_module.c index 7b2fb74..16beb7f 100644 --- a/src/tbm_module.c +++ b/src/tbm_module.c @@ -648,20 +648,18 @@ int tbm_module_support_surface_data(tbm_module *module) { tbm_error_e error = TBM_ERROR_NONE; - tbm_backend_surface_data *surface_data = NULL; - - static int tbm_module_check_support_surface_data = 0; + tbm_surface_data *surface_data = NULL; TBM_RETURN_VAL_IF_FAIL(module, 0); // check once support_surface_data or not. - if (tbm_module_check_support_surface_data) { + if (module->check_surface_data) { // return the value which already set. return module->support_surface_data; } // check this only once - tbm_module_check_support_surface_data = 1; + module->check_surface_data = 1; if (module->type != TBM_MODULE_TYPE_HAL_TBM) goto done; @@ -679,15 +677,15 @@ done: } -tbm_backend_surface_data * +tbm_surface_data * tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int format, int flags, tbm_error_e *error) { - tbm_backend_surface_data *surface_data = NULL; + tbm_surface_data *surface_data = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION); - surface_data = calloc(1, sizeof(struct _tbm_backend_surface_data)); + surface_data = calloc(1, sizeof(struct _tbm_surface_data)); if (!surface_data) { TBM_ERR("memory allocation failed."); *error = TBM_ERROR_OUT_OF_MEMORY; @@ -703,8 +701,8 @@ tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int for 0, (hal_tbm_error *)error); if (!surface_data->hal_surface) { - TBM_ERR("hal_tbm_bufmgr_alloc_surface failed."); - *error = TBM_ERROR_INVALID_OPERATION; + if (*error != TBM_ERROR_NOT_SUPPORTED) // do not print the error message when it is not supported. + TBM_ERR("hal_tbm_bufmgr_alloc_surface failed."); free(surface_data); return NULL; } @@ -714,15 +712,15 @@ tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int for return surface_data; } -tbm_backend_surface_data * +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_surface_data *surface_data = NULL; + tbm_surface_data *surface_data = NULL; TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION); - surface_data = calloc(1, sizeof(struct _tbm_backend_surface_data)); + surface_data = calloc(1, sizeof(struct _tbm_surface_data)); if (!surface_data) { TBM_ERR("memory allocation failed."); *error = TBM_ERROR_OUT_OF_MEMORY; @@ -747,177 +745,270 @@ 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)); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY); + 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); + TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: bufmgr_func = module->bufmgr_func; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, failed, *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); + TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, failed, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data->priv = (void *)backend->bo_alloc(bo, size, flags); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION); - bo_data = (void *)module->backend->bo_alloc(bo, size, flags); *error = TBM_ERROR_NONE; break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + goto failed; break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; + +/* LCOV_EXCL_START */ +failed: + if (bo_data) + free(bo_data); + + return NULL; +/* LCOV_EXCL_STOP */ } -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)); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY); + 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) + goto failed; break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: bufmgr_func = module->bufmgr_func; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION); if (!bufmgr_func->bufmgr_alloc_bo_with_format) { *error = TBM_ERROR_NOT_SUPPORTED; - return NULL; + goto failed; } - 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) + goto failed; 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."); + TBM_ERR("error: not supported tbm_module_alloc_bo_data_with_format."); *error = TBM_ERROR_NOT_SUPPORTED; + goto failed; break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + goto failed; break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; -} +/* LCOV_EXCL_START */ +failed: + if (bo_data) + free(bo_data); + + return NULL; +/* LCOV_EXCL_STOP */ +} -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)); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY); + 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); + TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: bufmgr_func = module->bufmgr_func; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, failed, *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); + TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); backend = module->backend; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_import_fd, failed, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = (void *)backend->bo_import_fd(bo, fd); - if (!bo_data) - *error = TBM_ERROR_INVALID_OPERATION; - else - *error = TBM_ERROR_NONE; + bo_data->priv = (void *)backend->bo_import_fd(bo, fd); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION); + + *error = TBM_ERROR_NONE; break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + goto failed; break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; + +/* LCOV_EXCL_START */ +failed: + if (bo_data) + free(bo_data); + + return NULL; +/* LCOV_EXCL_STOP */ } -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)); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY); + 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); + TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed); break; /* LCOV_EXCL_START */ case TBM_MODULE_TYPE_TBM_BACKEND: bufmgr_func = module->bufmgr_func; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, failed, *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); + TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed); break; case TBM_MODULE_TYPE_BUFMGR_BACKEND: TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); backend = module->backend; - 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); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_import, failed, *error, TBM_ERROR_NOT_SUPPORTED); - bo_data = (void *)backend->bo_import(bo, key); - if (!bo_data) - *error = TBM_ERROR_INVALID_OPERATION; - else - *error = TBM_ERROR_NONE; + bo_data->priv = (void *)backend->bo_import(bo, key); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION); + + *error = TBM_ERROR_NONE; break; default: TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; + goto failed; break; /* LCOV_EXCL_STOP */ } + bo_data->module = module; + return bo_data; + +/* LCOV_EXCL_START */ +failed: + if (bo_data) + free(bo_data); + + return NULL; +/* LCOV_EXCL_STOP */ +} + +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_backend_surface_data *surface_data) +tbm_surface_data_free(tbm_surface_data *surface_data) { TBM_RETURN_IF_FAIL(surface_data); TBM_RETURN_IF_FAIL(surface_data->module); @@ -932,7 +1023,7 @@ tbm_surface_data_free(tbm_backend_surface_data *surface_data) } tbm_error_e -tbm_surface_data_get_plane_data(tbm_backend_surface_data *surface_data, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx) +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_error_e error; @@ -945,10 +1036,12 @@ tbm_surface_data_get_plane_data(tbm_backend_surface_data *surface_data, int plan return TBM_ERROR_NONE; } -tbm_backend_bo_data ** -tbm_surface_data_get_bo_data_array(tbm_backend_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, int *memory_types, 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,11 +1049,39 @@ tbm_surface_data_get_bo_data_array(tbm_backend_surface_data *surface_data, int * 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(tbm_bo_data *)); + TBM_RETURN_VAL_IF_FAIL(bo_data_array, NULL); + + for (i = 0; i < *num_bos; i++) { + bo_data_array[i] = calloc(*num_bos, sizeof(struct _tbm_bo_data)); + TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data_array[i], failed, *error, TBM_ERROR_OUT_OF_MEMORY); + } + + for (i = 0; i < *num_bos; i++) { + bo_data_array[i]->hal_bo = hal_bos[i]; + bo_data_array[i]->module = surface_data->module; + } + + // get memory_types(bo flags) + *memory_types = tbm_bo_data_get_memory_types(bo_data_array[0], error); + TBM_GOTO_VAL_IF_FAIL(*error == TBM_ERROR_NONE, failed); + + return bo_data_array; + +/* LCOV_EXCL_START */ +failed: + for (i = 0; i < *num_bos; i++) { + if (bo_data_array[i]) + free(bo_data_array[i]); + } + free(bo_data_array); + + return NULL; +/* LCOV_EXCL_STOP */ } tbm_surface_buffer_data * -tbm_surface_data_export(tbm_backend_surface_data *surface_data, tbm_error_e *error) +tbm_surface_data_export(tbm_surface_data *surface_data, tbm_error_e *error) { tbm_surface_buffer_data *buffer_data; @@ -975,20 +1096,24 @@ tbm_surface_data_export(tbm_backend_surface_data *surface_data, tbm_error_e *err } void -tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int get_from_hal_surface) +tbm_bo_data_free(tbm_bo_data *bo_data, int get_from_surface_data) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; - TBM_RETURN_IF_FAIL(module); - TBM_RETURN_IF_FAIL(bo); TBM_RETURN_IF_FAIL(bo_data); + TBM_RETURN_IF_FAIL(bo_data->module); + + module = bo_data->module; 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_hal_surface) - 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 +1121,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,27 +1130,35 @@ 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_bo_data_get_size(tbm_bo_data *bo_data, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; int size = 0; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +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(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 +1174,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,17 +1191,21 @@ 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_bo_data_get_memory_types(tbm_bo_data *bo_data, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; int memory_types = TBM_BO_DEFAULT; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1213,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 +1221,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,18 +1235,22 @@ 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_bo_data_get_handle(tbm_bo_data *bo_data, int device, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_bo_handle bo_handle = (tbm_bo_handle)NULL; hal_tbm_bo_handle hbo_handle; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1260,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 +1268,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,18 +1286,22 @@ 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_bo_data_map(tbm_bo_data *bo_data, int device, int opt, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_bo_handle bo_handle = (tbm_bo_handle)NULL; - hal_tbm_bo_handle hbo_handle; + hal_tbm_bo_handle hbo_handle = (hal_tbm_bo_handle)NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + module = bo_data->module; 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 +1311,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 +1319,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,18 +1337,22 @@ 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_bo_data_unmap(tbm_bo_data *bo_data) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_error_e error; int ret = 0; - TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1360,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 +1368,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 = bo->bufmgr->backend->bo_unmap(bo); + ret = backend->bo_unmap(bo_data->priv); if (!ret) error = TBM_ERROR_INVALID_OPERATION; else @@ -1235,18 +1385,22 @@ 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_bo_data_lock(tbm_bo_data *bo_data, int device, int opt) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_error_e error; int ret = 0; - TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1409,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 +1418,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,17 +1435,21 @@ 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_bo_data_unlock(tbm_bo_data *bo_data) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_error_e error; - TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1458,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 +1467,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,17 +1481,21 @@ 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_bo_data_export_fd(tbm_bo_data *bo_data, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_fd fd; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, -1, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, -1, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, -1, *error, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1503,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 +1511,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,17 +1529,21 @@ 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_bo_data_export_key(tbm_bo_data *bo_data, tbm_error_e *error) { + tbm_module *module = NULL; tbm_backend_bo_func *bo_func = NULL; tbm_bufmgr_backend backend = NULL; tbm_key ret; - TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + module = bo_data->module; 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 +1551,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 +1559,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