implement the backend funtion for hal_tbm_surface.

Change-Id: I3866398d537d38f0225e83ee96f961222761354b

diff --git a/src/libhal-backend-tbm-vc4/tbm_backend_vc4.c b/src/libhal-backend-tbm-vc4/tbm_backend_vc4.c
index 7f45e83..f401a9b 100644 (file)
--- a/src/libhal-backend-tbm-vc4/tbm_backend_vc4.c
+++ b/src/libhal-backend-tbm-vc4/tbm_backend_vc4.c
@@ -1507,6 +1507,69 @@ static hal_tbm_surface *
 tbm_vc4_bufmgr_alloc_surface(hal_tbm_bufmgr *bufmgr, uint32_t width, uint32_t height, hal_tbm_format format,
                        hal_tbm_bo_memory_type mem_types, uint64_t *modifiers, uint32_t num_modifiers, hal_tbm_error *error)
 {
+       tbm_vc4_bufmgr *bufmgr_data = (tbm_vc4_bufmgr *)bufmgr;
+       tbm_vc4_surface *surface_data;
+       tbm_vc4_bo *bo_data;
+       uint32_t size = 0, offset = 0, pitch = 0;
+       int bo_idx = 0, bo_size = 0;
+       int i, num_planes;
+
+       if (bufmgr_data == NULL) {
+               TBM_BACKEND_ERR("bufmgr is null");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       surface_data = _tbm_vc4_surface_data_create(bufmgr_data, width, height, format, error);
+       if (!surface_data) {
+               TBM_BACKEND_ERR("fail to create surface_data");
+               return NULL;
+       }
+
+       num_planes = _tbm_vc4_bufmgr_get_num_planes(format);
+       if (num_planes == 0) {
+               TBM_BACKEND_ERR("fail to get num_planes");
+               _tbm_vc4_surface_data_destroy(surface_data);
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       for (i = 0; i < num_planes; i++) {
+               *error = tbm_vc4_bufmgr_get_plane_data(bufmgr, format, i, (int)width, (int)height, &size, &offset, &pitch, &bo_idx);
+               if (*error != HAL_TBM_ERROR_NONE) {
+                       _tbm_vc4_surface_data_destroy(surface_data);
+                       TBM_BACKEND_ERR("fail to get plane_data");
+                       return NULL;
+               }
+               bo_size += size;
+       }
+
+       bo_data = tbm_vc4_bufmgr_alloc_bo(bufmgr, bo_size, mem_types, error);
+       if (!bo_data) {
+               TBM_BACKEND_ERR("fail to allocate the bo_data");
+               _tbm_vc4_surface_data_destroy(surface_data);
+               if (error)
+                       *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
+               return NULL;
+       }
+       _tbm_vc4_surface_data_set_bo_data(surface_data, bo_data);
+
+       return (hal_tbm_surface *)surface_data;
+}
+
+static tbm_vc4_surface *
+_tbm_vc4_surface_find_same_surface(tbm_vc4_bufmgr *bufmgr_data, tbm_vc4_bo *bo_data)
+{
+       tbm_vc4_surface *s = NULL;
+
+       LIST_FOR_EACH_ENTRY(s, &bufmgr_data->surface_data_list, link) {
+               if (s->bo_data == bo_data) {
+                       return s;
+               }
+       }
+
        return NULL;
 }
 
@@ -1514,7 +1577,64 @@ static hal_tbm_surface *
 tbm_vc4_bufmgr_import_surface(hal_tbm_bufmgr *bufmgr, uint32_t width, uint32_t height, hal_tbm_format format,
                        hal_tbm_surface_buffer_data *buffer_data, hal_tbm_error *error)
 {
-       return NULL;
+       tbm_vc4_bufmgr *bufmgr_data = (tbm_vc4_bufmgr *)bufmgr;
+       tbm_vc4_surface *surface_data, *surface_data1;
+       tbm_vc4_bo *bo_data;
+
+       if (bufmgr_data == NULL) {
+               TBM_BACKEND_ERR("bufmgr is null");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       if (buffer_data == NULL) {
+               TBM_BACKEND_ERR("buffer_data is null");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       // vc4 backend allows to import only one dmabuf-fd.
+       if (buffer_data->num_fds != 1) {
+               TBM_BACKEND_ERR("buffer_data->num_fds MUST BE 1.");
+               TBM_BACKEND_ERR("vc4 backend can only import surface with just one dmabuf-fd.");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       if (buffer_data->fds == NULL) {
+               TBM_BACKEND_ERR("buffer_data->fds is null");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       surface_data = _tbm_vc4_surface_data_create(bufmgr_data, width, height, format, error);
+       if (!surface_data) {
+               TBM_BACKEND_ERR("fail to create surface_data");
+               return NULL;
+       }
+
+       bo_data = tbm_vc4_bufmgr_import_fd(bufmgr, buffer_data->fds[0], error);
+       if (!bo_data) {
+               TBM_BACKEND_ERR("fail to import the bo_data");
+               _tbm_vc4_surface_data_destroy(surface_data);
+               return NULL;
+       }
+
+       // reuse the surface_data when there is a surface_data which already has the same bo_data.
+       surface_data1 = _tbm_vc4_surface_find_same_surface(bufmgr_data, bo_data);
+       if (surface_data1) {
+               _tbm_vc4_surface_data_destroy(surface_data);
+               surface_data = surface_data1;
+               surface_data->refcnt++;
+       } else {
+               _tbm_vc4_surface_data_set_bo_data(surface_data, bo_data);
+       }
+
+       return (hal_tbm_surface *)surface_data;
 }
 
 static hal_tbm_bo *
@@ -1833,25 +1953,125 @@ tbm_vc4_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_error
 static void
 tbm_vc4_surface_free(hal_tbm_surface *surface)
 {
+       tbm_vc4_surface *surface_data = (tbm_vc4_surface *)surface;
+
+       if (!surface_data)
+               return;
 
+       _tbm_vc4_surface_data_destroy(surface_data);
 }
 
 static hal_tbm_bo **
 tbm_vc4_surface_get_bos(hal_tbm_surface *surface, int *num_bos, hal_tbm_error *error)
 {
-       return NULL;
+       tbm_vc4_surface *surface_data = (tbm_vc4_surface *)surface;
+       hal_tbm_surface **bos;
+
+       if (surface_data == NULL) {
+               TBM_BACKEND_ERR("surface_data is null\n");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       if (num_bos == NULL) {
+               TBM_BACKEND_ERR("num_bos is null\n");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       *num_bos = surface_data->num_bos;
+
+       /* will be freed in frontend */
+       bos = calloc(*num_bos, sizeof(tbm_vc4_bo *));
+       if (!bos) {
+               TBM_BACKEND_ERR("failed: alloc bos");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+       bos[0] = surface_data->bo_data;
+
+       if (error)
+               *error = HAL_TBM_ERROR_NONE;
+
+       return bos;
 }
 
 static hal_tbm_error
 tbm_vc4_surface_get_plane_data(hal_tbm_surface *surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
 {
+       tbm_vc4_surface *surface_data = (tbm_vc4_surface *)surface;
+       hal_tbm_error error;
+       tbm_vc4_bufmgr *bufmgr;
+       uint32_t width, height;
+       hal_tbm_format format;
+
+       if (surface_data == NULL) {
+               TBM_BACKEND_ERR("surface_data is null");
+               return HAL_TBM_ERROR_INVALID_PARAMETER;
+       }
+
+       bufmgr = surface_data->bufmgr_data;
+       width = surface_data->width;
+       height = surface_data->height;
+       format = surface_data->format;
+
+       error = tbm_vc4_bufmgr_get_plane_data((tbm_vc4_bufmgr *)bufmgr, format, plane_idx,
+                                       (int)width, (int)height, size, offset, pitch, bo_idx);
+       if (error != HAL_TBM_ERROR_NONE) {
+               TBM_BACKEND_ERR("fail to get plane_data");
+               return HAL_TBM_ERROR_INVALID_PARAMETER;
+       }
+
        return HAL_TBM_ERROR_NONE;
 }
 
 static hal_tbm_surface_buffer_data *
 tbm_vc4_surface_export(hal_tbm_surface *surface, hal_tbm_error *error)
 {
-       return NULL;
+       tbm_vc4_surface *surface_data = (tbm_vc4_surface *)surface;
+       hal_tbm_surface_buffer_data *buffer_data;
+
+       if (surface == NULL) {
+               TBM_BACKEND_ERR("surface is null");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               return NULL;
+       }
+
+       buffer_data = calloc(1, sizeof(struct _hal_tbm_surface_buffer_data));
+       if (!buffer_data) {
+               TBM_BACKEND_ERR("fail to allocate a buffer_data");
+               if (error)
+                       *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
+               return NULL;
+       }
+       buffer_data->num_fds = surface_data->num_bos;
+
+       /* will be freed in frontend */
+       buffer_data->fds = calloc(buffer_data->num_fds, sizeof(int));
+       if (!buffer_data->fds) {
+               TBM_BACKEND_ERR("failed: alloc bos");
+               if (error)
+                       *error = HAL_TBM_ERROR_INVALID_PARAMETER;
+               free(buffer_data);
+               return NULL;
+       }
+
+       buffer_data->fds[0] = tbm_vc4_bo_export_fd(surface_data->bo_data, error);
+       if (buffer_data->fds[0] < 0) {
+               TBM_BACKEND_ERR("fail to export bo_data");
+               free(buffer_data->fds);
+               free(buffer_data);
+               return NULL;
+       }
+
+       if (error)
+               *error = HAL_TBM_ERROR_NONE;
+
+       return buffer_data;
 }
 
 static void