tbm_surface_internal: tbm_surface_internal_import

It returns tbm_surface_h from buffer_data.

Change-Id: Ib7f91c092d0c73cc9b707ad6ad3d8262d365b4cd

diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c
index 00f9454..5f8ebcb 100644 (file)
--- a/src/tbm_surface_internal.c
+++ b/src/tbm_surface_internal.c
@@ -933,6 +933,133 @@ alloc_surf_fail:
        return NULL;
 }
 
+static struct _tbm_surface *
+_tbm_surface_internal_hal_tbm_import_surface(tbm_bufmgr bufmgr, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
+{
+       struct _tbm_surface *surf = NULL;
+       uint32_t size = 0, offset = 0, stride = 0;
+       int i, j, bo_idx;
+       hal_tbm_surface *hal_surface = NULL;
+       hal_tbm_bo **hal_bos = NULL;
+       int num_bos = 0;
+       int flags;
+
+       surf = calloc(1, sizeof(struct _tbm_surface));
+       if (!surf) {
+               /* LCOV_EXCL_START */
+               TBM_ERR("fail to alloc surf");
+               *error = TBM_ERROR_OUT_OF_MEMORY;
+               goto alloc_surf_fail;
+               /* LCOV_EXCL_STOP */
+       }
+       surf->refcnt = 1;
+
+       surf->magic = TBM_SURFACE_MAGIC;
+       surf->bufmgr = bufmgr;
+       surf->info.width = width;
+       surf->info.height = height;
+       surf->info.format = format;
+       surf->info.bpp = _tbm_surface_internal_get_bpp(format);
+       if (!surf->info.bpp) {
+               TBM_ERR("fail to get bpp from format(%d), error(%s)", format, tbm_error_str(*error));
+               *error = tbm_get_last_error();
+               goto bpp_fail;
+       }
+
+       // get number of planes
+       surf->info.num_planes = _tbm_surface_internal_get_num_planes(format);
+       if (!surf->info.num_planes) {
+               TBM_ERR("fail to get num_planes from format(%d), error(%s)", format, tbm_error_str(*error));
+               *error = tbm_get_last_error();
+               goto num_planes_fail;
+       }
+
+       // import surface
+       hal_surface = hal_tbm_bufmgr_import_surface(bufmgr->hal_bufmgr, 
+                                                                                       (uint32_t)width,
+                                                                                       (uint32_t)height,
+                                                                                       (hal_tbm_format)format,
+                                                                                       (hal_tbm_surface_buffer_data *)buffer_data,
+                                                                                       (hal_tbm_error *)error);
+       if (!hal_surface) {
+               TBM_ERR("hal_tbm_bufmgr_import_surface failed.(width:%d height:%d format:%d error:%s)",
+                               width, height, format, tbm_error_str(*error));
+               goto import_surface_fail;
+       }
+       surf->hal_surface = hal_surface;
+
+       // set infomation of planes
+       for (i = 0; i < surf->info.num_planes; i++) {
+               *error = (tbm_error_e)hal_tbm_surface_get_plane_data(hal_surface, i, &size, &offset, &stride, &bo_idx);
+               if (*error != TBM_ERROR_NONE) {
+                       goto query_plane_data_fail;
+               }
+               surf->info.planes[i].size = size;
+               surf->info.planes[i].offset = offset;
+               surf->info.planes[i].stride = stride;
+               surf->planes_bo_idx[i] = bo_idx;
+       }
+
+       // set infomation of bos
+       hal_bos = hal_tbm_surface_get_bos(hal_surface, &num_bos, (hal_tbm_error *)error);
+       if (!hal_bos) {
+               TBM_ERR("fail to get bos, error(%s)", tbm_error_str(*error));
+               goto get_bos_fail;
+       }
+       surf->num_bos = num_bos;
+
+       for (i = 0; i < surf->info.num_planes; i++) {
+               surf->info.size += surf->info.planes[i].size;
+
+               if (surf->num_bos < surf->planes_bo_idx[i] + 1)
+                       surf->num_bos = surf->planes_bo_idx[i] + 1;
+       }
+
+       // get memory_types(bo flags)
+       flags =  (int)hal_tbm_bo_get_memory_types(hal_bos[0], (hal_tbm_error *)error);
+       if (*error != TBM_ERROR_NONE) {
+               TBM_ERR("hal_tbm_bo_get_memory_types failed.");
+               goto get_memory_types_fail;
+       }
+       surf->flags = flags;
+
+       for (i = 0; i < num_bos; i++) {
+               surf->bos[i] = tbm_bo_alloc_with_bo_data(bufmgr, (tbm_backend_bo_data *)hal_bos[i], flags);
+               if (!surf->bos[i]) {
+                       TBM_ERR("fail to alloc bo idx:%d", i);
+                       *error = tbm_get_last_error();
+                       goto get_bo_fail;
+               }
+
+               _tbm_bo_set_surface(surf->bos[i], surf);
+       }
+
+       *error = TBM_ERROR_NONE;
+
+       return surf;
+
+get_bo_fail:
+get_memory_types_fail:
+get_bos_fail:
+query_plane_data_fail:
+       if (hal_surface) {
+               hal_tbm_surface_free(hal_surface);
+       } else {
+               for (j = 0; j < i; j++) {
+                       if (surf->bos[j])
+                               tbm_bo_unref(surf->bos[j]);
+               }
+       }
+import_surface_fail:
+num_planes_fail:
+bpp_fail:
+       if (surf)
+               free(surf);
+alloc_surf_fail:
+
+       return NULL;
+}
+
 int
 tbm_surface_internal_is_valid(tbm_surface_h surface)
 {
@@ -2981,8 +3108,46 @@ tbm_surface_internal_export(tbm_surface_h surface, tbm_error_e *error)
 tbm_surface_h
 tbm_surface_internal_import(tbm_surface_info_s *surface_info, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
 {
-       // TODO: implement
-       return NULL;
+       struct _tbm_surface *surf;
+       struct _tbm_bufmgr *bufmgr;
+
+       _tbm_surface_mutex_lock();
+
+       bufmgr = g_surface_bufmgr;
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
+
+       // this function supports when it comes to be use_hal.
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr->use_hal_tbm, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
+
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info->width > 0, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(surface_info->height > 0, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
+       TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(buffer_data != NULL, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
+
+       // import a surface
+       surf = _tbm_surface_internal_hal_tbm_import_surface(bufmgr,
+                                                                                                       (int)surface_info->width,
+                                                                                                       (int)surface_info->height,
+                                                                                                       (int)surface_info->format,
+                                                                                                       buffer_data,
+                                                                                                       error);
+       TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(surf != NULL, NULL, *error);
+
+       LIST_INITHEAD(&surf->user_data_list);
+       LIST_INITHEAD(&surf->debug_data_list);
+       LIST_INITHEAD(&surf->destroy_funcs);
+
+       LIST_ADD(&surf->item_link, &bufmgr->surf_list);
+
+       TBM_TRACE_SURFACE_INTERNAL("tbm_surface(%p)", surf);
+
+       if (error)
+               *error = TBM_ERROR_NONE;
+
+       _tbm_set_last_result(TBM_ERROR_NONE);
+       _tbm_surface_mutex_unlock();
+
+       return (tbm_surface_h)surf;
 }
 
 /*LCOV_EXCL_STOP*/