tbm_surface_internal: implement tbm_surface functions with tbm_suface_data api

Use tbm_surface_data instead of hal_tbm_surface at tbm_surface_internal.c

Change-Id: I137edbfd63756c1c975731baae05cedd554de4be

diff --git a/src/tbm_bufmgr_int.h b/src/tbm_bufmgr_int.h
index 3cf6cad..ed6a2a5 100644 (file)
--- a/src/tbm_bufmgr_int.h
+++ b/src/tbm_bufmgr_int.h
@@ -268,7 +268,6 @@ struct _tbm_surface {
        } damage;
 
        tbm_backend_surface_data *surface_data; /* surface data of the backend module */
-       hal_tbm_surface *hal_surface; // hal_tbm_surface
 };
 
 typedef struct {

diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c
index bf45028..90e4758 100644 (file)
--- a/src/tbm_surface_internal.c
+++ b/src/tbm_surface_internal.c
@@ -380,9 +380,9 @@ _tbm_surface_internal_destroy(tbm_surface_h surface)
        LIST_DEL(&surface->item_link);
        surface->magic = 0;
 
-       if (surface->hal_surface) {
-               hal_tbm_surface_free(surface->hal_surface);
-               surface->hal_surface = NULL;
+       if (surface->surface_data) {
+               tbm_surface_data_free(surface->surface_data);
+               surface->surface_data = NULL;
        }
 
        free(surface);
@@ -694,13 +694,12 @@ alloc_surf_fail:
 }
 
 static struct _tbm_surface *
-_tbm_surface_internal_hal_tbm_create_surface(tbm_bufmgr bufmgr, int width, int height, int format, int flags, tbm_error_e *error)
+_tbm_surface_internal_create_surface_data(tbm_bufmgr bufmgr, int width, int height, int format, int flags, tbm_error_e *error)
 {
        struct _tbm_surface *surf = NULL;
-       uint32_t size = 0, offset = 0, stride = 0, bo_size = 0;
+       uint32_t size = 0, offset = 0, stride = 0;
        int i, j, bo_idx;
-       hal_tbm_surface *hal_surface = NULL;
-       hal_tbm_bo **hal_bos = NULL;
+       tbm_backend_bo_data **bo_data_array = NULL;
        int num_bos = 0;
 
        surf = calloc(1, sizeof(struct _tbm_surface));
@@ -734,91 +733,48 @@ _tbm_surface_internal_hal_tbm_create_surface(tbm_bufmgr bufmgr, int width, int h
                goto num_planes_fail;
        }
 
-       hal_surface = hal_tbm_bufmgr_alloc_surface(bufmgr->hal_bufmgr, (uint32_t)width, (uint32_t)height, (hal_tbm_format)format, (hal_tbm_bo_memory_type)flags, NULL, 0, (hal_tbm_error *)error);
-       if (hal_surface) {
-               // set hal_surface
-               surf->hal_surface = hal_surface;
-
-               // set infomation of planes
-               for (i = 0; i < surf->info.num_planes; i++) {
-                       *error = (tbm_error_e)hal_tbm_surface_get_plane_data(hal_surface, i, &size, &offset, &stride, &bo_idx);
-                       if (*error != TBM_ERROR_NONE) {
-                               goto query_plane_data_fail;
-                       }
-                       surf->info.planes[i].size = size;
-                       surf->info.planes[i].offset = offset;
-                       surf->info.planes[i].stride = stride;
-                       surf->planes_bo_idx[i] = bo_idx;
-               }
-
-               // set infomation of bos
-               hal_bos = hal_tbm_surface_get_bos(hal_surface, &num_bos, (hal_tbm_error *)error);
-               if (!hal_bos) {
-                       TBM_ERR("fail to get bos, error(%s)", tbm_error_str(*error));
-                       goto get_bos_fail;
-               }
-               surf->num_bos = num_bos;
-
-               for (i = 0; i < surf->info.num_planes; i++) {
-                       surf->info.size += surf->info.planes[i].size;
+       surf->surface_data = tbm_module_alloc_surface_data(bufmgr->module, width, height, format, flags, error);
+       if (!surf->surface_data) {
+               TBM_ERR("tbm_module_alloc_surface_data failed. error:%s", tbm_error_str(*error));
+               goto alloc_surface_data_fail;
+       }
 
-                       if (surf->num_bos < surf->planes_bo_idx[i] + 1)
-                               surf->num_bos = surf->planes_bo_idx[i] + 1;
+       // set infomation of planes
+       for (i = 0; i < surf->info.num_planes; i++) {
+               *error = tbm_surface_data_get_plane_data(surf->surface_data, i, &size, &offset, &stride, &bo_idx);
+               if (*error != TBM_ERROR_NONE) {
+                       goto query_plane_data_fail;
                }
+               surf->info.planes[i].size = size;
+               surf->info.planes[i].offset = offset;
+               surf->info.planes[i].stride = stride;
+               surf->planes_bo_idx[i] = bo_idx;
+       }
 
-               for (i = 0; i < num_bos; i++) {
-                       surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_bo_data(bufmgr, (tbm_backend_bo_data *)hal_bos[i], flags);
-                       if (!surf->bos[i]) {
-                               TBM_ERR("fail to alloc bo idx:%d", i);
-                               *error = tbm_get_last_error();
-                               goto get_bo_fail;
-                       }
+       // set infomation of bos
+       bo_data_array = tbm_surface_data_get_bo_data_array(surf->surface_data, &num_bos, error);
+       if (!bo_data_array) {
+               TBM_ERR("tbm_surface_data_get_bo_data_array failed. error:%s", tbm_error_str(*error));
+               goto get_bos_fail;
+       }
+       surf->num_bos = num_bos;
 
-                       _tbm_bo_set_surface(surf->bos[i], surf);
-               }
-       } else {
-               // set infomation of planes
-               for (i = 0; i < surf->info.num_planes; i++) {
-                       if (!_tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride, &bo_idx)) {
-                               TBM_ERR("fail to query plane data");
-                               *error = tbm_get_last_error();
-                               goto query_plane_data_fail;
-                       }
-                       surf->info.planes[i].size = size;
-                       surf->info.planes[i].offset = offset;
-                       surf->info.planes[i].stride = stride;
-                       surf->planes_bo_idx[i] = bo_idx;
-               }
+       for (i = 0; i < surf->info.num_planes; i++) {
+               surf->info.size += surf->info.planes[i].size;
 
-               // count number of bos
-               surf->num_bos = 1;
-               for (i = 0; i < surf->info.num_planes; i++) {
-                       surf->info.size += surf->info.planes[i].size;
+               if (surf->num_bos < surf->planes_bo_idx[i] + 1)
+                       surf->num_bos = surf->planes_bo_idx[i] + 1;
+       }
 
-                       if (surf->num_bos < surf->planes_bo_idx[i] + 1)
-                               surf->num_bos = surf->planes_bo_idx[i] + 1;
+       for (i = 0; i < num_bos; i++) {
+               surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_bo_data(bufmgr, bo_data_array[i], flags);
+               if (!surf->bos[i]) {
+                       TBM_ERR("fail to alloc bo idx:%d", i);
+                       *error = tbm_get_last_error();
+                       goto get_bo_fail;
                }
 
-               // set infomation of bos
-               for (i = 0; i < surf->num_bos; i++) {
-                       bo_size = 0;
-                       for (j = 0; j < surf->info.num_planes; j++) {
-                               if (surf->planes_bo_idx[j] == i)
-                                       bo_size += surf->info.planes[j].size;
-                       }
-
-                       surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_format(bufmgr, format, i, width, height, surf->info.bpp / 8, flags, error);
-                       if (*error == TBM_ERROR_NOT_SUPPORTED) {
-                               surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
-                               if (!surf->bos[i]) {
-                                       TBM_ERR("fail to alloc bo idx:%d", i);
-                                       *error = tbm_get_last_error();
-                                       goto get_bo_fail;
-                               }
-                       }
-
-                       _tbm_bo_set_surface(surf->bos[i], surf);
-               }
+               _tbm_bo_set_surface(surf->bos[i], surf);
        }
 
        *error = TBM_ERROR_NONE;
@@ -826,16 +782,15 @@ _tbm_surface_internal_hal_tbm_create_surface(tbm_bufmgr bufmgr, int width, int h
        return surf;
 
 get_bo_fail:
+       for (j = 0; j < i; j++) {
+               if (surf->bos[j])
+                       tbm_bo_unref(surf->bos[j]);
+       }
 get_bos_fail:
 query_plane_data_fail:
-       if (hal_surface) {
-               hal_tbm_surface_free(hal_surface);
-       } else {
-               for (j = 0; j < i; j++) {
-                       if (surf->bos[j])
-                               tbm_bo_unref(surf->bos[j]);
-               }
-       }
+       if (surf->surface_data)
+               tbm_surface_data_free(surf->surface_data);
+alloc_surface_data_fail:
 num_planes_fail:
 bpp_fail:
        if (surf)
@@ -846,13 +801,12 @@ alloc_surf_fail:
 }
 
 static struct _tbm_surface *
-_tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
+_tbm_surface_internal_import_surface_data(tbm_bufmgr bufmgr, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
 {
        struct _tbm_surface *surf = NULL;
        uint32_t size = 0, offset = 0, stride = 0;
        int i, j, bo_idx;
-       hal_tbm_surface *hal_surface = NULL;
-       hal_tbm_bo **hal_bos = NULL;
+       tbm_backend_bo_data **bo_data_array = NULL;
        int num_bos = 0;
        int flags;
 
@@ -887,22 +841,16 @@ _tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int h
        }
 
        // import surface
-       hal_surface = hal_tbm_bufmgr_import_surface(bufmgr->hal_bufmgr,
-                                                                                       (uint32_t)width,
-                                                                                       (uint32_t)height,
-                                                                                       (hal_tbm_format)format,
-                                                                                       (hal_tbm_surface_buffer_data *)buffer_data,
-                                                                                       (hal_tbm_error *)error);
-       if (!hal_surface) {
-               TBM_ERR("hal_tbm_bufmgr_import_surface failed.(width:%d height:%d format:%d error:%s)",
+       surf->surface_data = tbm_module_import_surface_data(bufmgr->module, width, height, format, buffer_data, error);
+       if (surf->surface_data) {
+               TBM_ERR("tbm_module_import_surface_data failed. width:%d height:%d format:%d error:%s",
                                width, height, format, tbm_error_str(*error));
                goto import_surface_fail;
        }
-       surf->hal_surface = hal_surface;
 
        // set infomation of planes
        for (i = 0; i < surf->info.num_planes; i++) {
-               *error = (tbm_error_e)hal_tbm_surface_get_plane_data(hal_surface, i, &size, &offset, &stride, &bo_idx);
+               *error = tbm_surface_data_get_plane_data(surf->surface_data, i, &size, &offset, &stride, &bo_idx);
                if (*error != TBM_ERROR_NONE) {
                        goto query_plane_data_fail;
                }
@@ -913,9 +861,9 @@ _tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int h
        }
 
        // set infomation of bos
-       hal_bos = hal_tbm_surface_get_bos(hal_surface, &num_bos, (hal_tbm_error *)error);
-       if (!hal_bos) {
-               TBM_ERR("fail to get bos, error(%s)", tbm_error_str(*error));
+       bo_data_array = tbm_surface_data_get_bo_data_array(surf->surface_data, &num_bos, error);
+       if (!bo_data_array) {
+               TBM_ERR("tbm_surface_data_get_bo_data_array failed. error:%s", tbm_error_str(*error));
                goto get_bos_fail;
        }
        surf->num_bos = num_bos;
@@ -928,15 +876,15 @@ _tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int h
        }
 
        // get memory_types(bo flags)
-       flags =  (int)hal_tbm_bo_get_memory_types(hal_bos[0], (hal_tbm_error *)error);
+       flags = tbm_module_bo_get_memory_types(bufmgr->module, NULL, bo_data_array[0], error);
        if (*error != TBM_ERROR_NONE) {
-               TBM_ERR("hal_tbm_bo_get_memory_types failed.");
+               TBM_ERR("tbm_module_bo_get_memory_types failed.error:%s", tbm_error_str(*error));
                goto get_memory_types_fail;
        }
        surf->flags = flags;
 
        for (i = 0; i < num_bos; i++) {
-               surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_bo_data(bufmgr, (tbm_backend_bo_data *)hal_bos[i], flags);
+               surf->bos[i] = tbm_bufmgr_internal_alloc_bo_with_bo_data(bufmgr, bo_data_array[i], flags);
                if (!surf->bos[i]) {
                        TBM_ERR("fail to alloc bo idx:%d", i);
                        *error = tbm_get_last_error();
@@ -956,7 +904,8 @@ get_bo_fail:
 get_memory_types_fail:
 get_bos_fail:
 query_plane_data_fail:
-       hal_tbm_surface_free(hal_surface);
+       if (surf->surface_data)
+               tbm_surface_data_free(surf->surface_data);
 import_surface_fail:
 num_planes_fail:
 bpp_fail:
@@ -1124,10 +1073,10 @@ tbm_surface_internal_create_with_flags(int width, int height,
                goto check_valid_fail;
        }
 
-       if (bufmgr->use_hal_tbm) {
-               surf = _tbm_surface_internal_hal_tbm_create_surface(bufmgr, width, height, format, flags, &error);
+       if (tbm_module_support_surface_data(bufmgr->module)) {
+               surf = _tbm_surface_internal_create_surface_data(bufmgr, width, height, format, flags, &error);
                if (!surf) {
-                       TBM_ERR("_tbm_surface_internal_hal_tbm_create_surface failed.");
+                       TBM_ERR("_tbm_surface_internal_create_surface_data failed.");
                        goto surface_alloc_fail;
                }
        } else {
@@ -2995,23 +2944,20 @@ tbm_surface_buffer_data *
 tbm_surface_internal_export(tbm_surface_h surface, tbm_error_e *error)
 {
        tbm_surface_buffer_data *buffer_data = NULL;
-       struct _tbm_surface *surf;
        struct _tbm_bufmgr *bufmgr;
 
        _tbm_surface_mutex_lock();
 
-       surf = (struct _tbm_surface *)surface;
-       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(_tbm_surface_internal_is_valid(surface), NULL, error, TBM_ERROR_INVALID_PARAMETER);
+       bufmgr = g_surface_bufmgr;
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, error, TBM_ERROR_INVALID_OPERATION);
 
-       bufmgr = surf->bufmgr;
-       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, error, TBM_ERROR_INVALID_PARAMETER);
+       // this function supports when the module suppport surface_data.
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(tbm_module_support_surface_data(bufmgr->module), NULL, error, TBM_ERROR_NOT_SUPPORTED);
 
-       // this function supports when it comes to be use_hal.
-       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr->use_hal_tbm, NULL, error, TBM_ERROR_NOT_SUPPORTED);
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(_tbm_surface_internal_is_valid(surface), NULL, error, TBM_ERROR_INVALID_PARAMETER);
 
        // export a surface
-       buffer_data = (tbm_surface_buffer_data *)hal_tbm_surface_export((hal_tbm_surface *)surf->hal_surface,
-                                                                                                                                       (hal_tbm_error *)error);
+       buffer_data = tbm_surface_data_export(surface->surface_data, error);
        TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(buffer_data != NULL, NULL, *error);
 
        TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p) buffer_data(%p)", surface, buffer_data);
@@ -3031,10 +2977,10 @@ tbm_surface_internal_import(tbm_surface_info_s *surface_info, tbm_surface_buffer
        _tbm_surface_mutex_lock();
 
        bufmgr = g_surface_bufmgr;
-       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, error, TBM_ERROR_INVALID_PARAMETER);
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, error, TBM_ERROR_INVALID_OPERATION);
 
-       // this function supports when it comes to be use_hal.
-       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr->use_hal_tbm, NULL, error, TBM_ERROR_NOT_SUPPORTED);
+       // this function supports when the module suppport surface_data.
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(tbm_module_support_surface_data(bufmgr->module), NULL, error, TBM_ERROR_NOT_SUPPORTED);
 
        TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info != NULL, NULL, error, TBM_ERROR_INVALID_PARAMETER);
        TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info->width > 0, NULL, error, TBM_ERROR_INVALID_PARAMETER);
@@ -3042,7 +2988,7 @@ tbm_surface_internal_import(tbm_surface_info_s *surface_info, tbm_surface_buffer
        TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(buffer_data != NULL, NULL, error, TBM_ERROR_INVALID_PARAMETER);
 
        // import a surface
-       surf = _tbm_surface_internal_hal_tbm_import_surface(bufmgr,
+       surf = _tbm_surface_internal_import_surface_data(bufmgr,
                                                                                                        (int)surface_info->width,
                                                                                                        (int)surface_info->height,
                                                                                                        (int)surface_info->format,