X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2Ftbm_surface_internal.c;h=3b88a08f885b0714ca0ad43d5f0bd1986f83ae93;hb=0685d37af53e41e7ad4daa7aea7c799c5642a198;hp=79f94a62da486e1fc4b9947ae1df4fde5712b239;hpb=e08f8e51581c9d88c776f2efe1db677a01f71737;p=platform%2Fcore%2Fuifw%2Flibtbm.git

diff --git a/src/tbm_surface_internal.c b/src/tbm_surface_internal.c
index 79f94a6..3b88a08 100644
--- a/src/tbm_surface_internal.c
+++ b/src/tbm_surface_internal.c
@@ -57,6 +57,25 @@ void _tbm_surface_mutex_unlock(void);
 	} \
 }
 
+#define TBM_SURFACE_RETURN_ERR_IF_FAIL(cond, error_type) {\
+	if (!(cond)) {\
+		TBM_ERR("'%s' failed.\n", #cond);\
+		_tbm_set_last_result(error_type);\
+		_tbm_surface_mutex_unlock();\
+		return;\
+	} \
+}
+
+#define TBM_SURFACE_RETURN_SET_ERR_IF_FAIL(cond, error, error_type) {\
+	if (!(cond)) {\
+		TBM_ERR("'%s' failed.\n", #cond);\
+		error = error_type;\
+		_tbm_set_last_result(error_type);\
+		_tbm_surface_mutex_unlock();\
+		return;\
+	} \
+}
+
 #define TBM_SURFACE_RETURN_VAL_IF_FAIL(cond, val) {\
 	if (!(cond)) {\
 		TBM_ERR("'%s' failed.\n", #cond);\
@@ -66,6 +85,26 @@ void _tbm_surface_mutex_unlock(void);
 	} \
 }
 
+
+#define TBM_SURFACE_RETURN_VAL_ERR_IF_FAIL(cond, val, error_type) {\
+	if (!(cond)) {\
+		TBM_ERR("'%s' failed.\n", #cond);\
+		_tbm_set_last_result(error_type);\
+		_tbm_surface_mutex_unlock();\
+		return val;\
+	} \
+}
+
+#define TBM_SURFACE_RETURN_VAL_SET_ERR_IF_FAIL(cond, val, error, error_type) {\
+	if (!(cond)) {\
+		TBM_ERR("'%s' failed.\n", #cond);\
+		error = error_type;\
+		_tbm_set_last_result(error_type);\
+		_tbm_surface_mutex_unlock();\
+		return val;\
+	} \
+}
+
 /* LCOV_EXCL_START */
 static double
 _tbm_surface_internal_get_time(void)
@@ -382,6 +421,11 @@ _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;
+	}
+
 	free(surface);
 	surface = NULL;
 
@@ -659,60 +703,13 @@ _tbm_surface_internal_create_surface(tbm_bufmgr bufmgr, int width, int height, i
 				bo_size += surf->info.planes[j].size;
 		}
 
-		if (bufmgr->use_hal_tbm) {
-			surf->bos[i] = tbm_bo_alloc_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\n", i);
-					*error = tbm_get_last_error();
-					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, surf->info.bpp/8, flags, error);
-				if (!surf->bos[i]) {
-					TBM_ERR("fail to tbm_bo_alloc_with_format idx:%d\n", i);
-					*error = tbm_get_last_error();
-					goto alloc_bo_fail;
-				}
-				/* LCOV_EXCL_STOP */
-			} else if (bufmgr->bufmgr_func->bufmgr_alloc_bo_with_tiled_format && (flags & TBM_BO_TILED)) {
-				/* LCOV_EXCL_START */
-				surf->bos[i] = tbm_bo_alloc_with_tiled_format(bufmgr, width, height, surf->info.bpp/8, format, flags, i, error);
-				if (!surf->bos[i]) {
-					TBM_ERR("fail to tbm_bo_alloc_with_tiled_format idx:%d\n", i);
-					*error = tbm_get_last_error();
-					goto alloc_bo_fail;
-				}
-				/* LCOV_EXCL_STOP */
-			} 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);
-					*error = tbm_get_last_error();
-					goto alloc_bo_fail;
-				}
-			}
-		} else {
-			if (bufmgr->backend->surface_bo_alloc) {
-				/* LCOV_EXCL_START */
-				surf->bos[i] = tbm_bo_alloc_with_surface(bufmgr, width, height, format, flags, i);
-				if (!surf->bos[i]) {
-					TBM_ERR("fail to tbm_bo_alloc_with_surface idx:%d\n", i);
-					*error = tbm_get_last_error();
-					goto alloc_bo_fail;
-				/* LCOV_EXCL_STOP */
-				}
-			} 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);
-					*error = tbm_get_last_error();
-					goto alloc_bo_fail;
-				}
+		surf->bos[i] = tbm_bo_alloc_with_format(bufmgr, format, i, width, height, surf->info.bpp/8, flags, error);
+		if (!surf->bos[i]) {
+			surf->bos[i] = tbm_bo_alloc(bufmgr, bo_size, flags);
+			if (!surf->bos[i]) {
+				TBM_ERR("fail to alloc bo idx:%d\n", i);
+				*error = tbm_get_last_error();
+				goto alloc_bo_fail;
 			}
 		}
 
@@ -737,6 +734,285 @@ alloc_surf_fail:
 	return NULL;
 }
 
+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)
+{
+	struct _tbm_surface *surf = NULL;
+	uint32_t size = 0, offset = 0, stride = 0, bo_size = 0;
+	int i, j, bo_idx;
+	hal_tbm_surface *hal_surface = NULL;
+	hal_tbm_bo **hal_bos = NULL;
+	int num_bos = 0;
+
+	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;
+	}
+	surf->flags = flags;
+
+	// 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;
+	}
+
+	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;
+
+			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_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);
+		}
+	} 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;
+		}
+
+		// 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;
+		}
+
+		// 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_bo_alloc_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);
+		}
+	}
+
+	*error = TBM_ERROR_NONE;
+
+	return surf;
+
+get_bo_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]);
+		}
+	}
+num_planes_fail:
+bpp_fail:
+	if (surf)
+		free(surf);
+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)
 {
@@ -931,11 +1207,18 @@ tbm_surface_internal_create_with_flags(int width, int height,
 		goto check_valid_fail;
 	}
 
-	// TODO: use_hal_tbm
-	surf = _tbm_surface_internal_create_surface(bufmgr, width, height, format, flags, &error);
-	if (!surf) {
-		TBM_ERR("_tbm_surface_internal_create_surface failed.");
-		goto surface_alloc_fail;
+	if (bufmgr->use_hal_tbm) {
+		surf = _tbm_surface_internal_hal_tbm_create_surface(bufmgr, width, height, format, flags, &error);
+		if (!surf) {
+			TBM_ERR("_tbm_surface_internal_hal_tbm_create_surface failed.");
+			goto surface_alloc_fail;
+		}
+	} else {
+		surf = _tbm_surface_internal_create_surface(bufmgr, width, height, format, flags, &error);
+		if (!surf) {
+			TBM_ERR("_tbm_surface_internal_create_surface failed.");
+			goto surface_alloc_fail;
+		}
 	}
 
 	TBM_TRACE_SURFACE_INTERNAL("width(%d) height(%d) format(%s) flags(%d) tbm_surface(%p)\n",
@@ -1139,6 +1422,8 @@ tbm_surface_internal_destroy(tbm_surface_h surface)
 
 	if (surface->refcnt == 0)
 		_tbm_surface_internal_destroy(surface);
+	else // if (surface->refcnt < 0)
+		_tbm_set_last_result(TBM_ERROR_INVALID_PARAMETER);
 
 	_tbm_surface_mutex_unlock();
 }
@@ -2742,15 +3027,80 @@ tbm_surface_internal_remove_destroy_handler(tbm_surface_h surface, tbm_surface_i
 tbm_surface_buffer_data *
 tbm_surface_internal_export(tbm_surface_h surface, tbm_error_e *error)
 {
-	// TODO: implement
-	return NULL;
+	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 = surf->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);
+
+	// export a surface
+	buffer_data = (tbm_surface_buffer_data *)hal_tbm_surface_export((hal_tbm_surface *)surf->hal_surface,
+																	(hal_tbm_error *)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);
+
+	if (error)
+		*error = TBM_ERROR_NONE;
+
+	_tbm_set_last_result(TBM_ERROR_NONE);
+	_tbm_surface_mutex_unlock();
+
+	return buffer_data;
 }
 
 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*/