1 /**************************************************************************
3 * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: SooChan Lim <sc1.lim@samsung.com>
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sub license, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
15 * The above copyright notice and this permission notice (including the
16 * next paragraph) shall be included in all copies or substantial portions
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
22 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
24 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
25 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 **************************************************************************/
31 #define UT_TBM_ITER_COUNT 100
33 class TBMBackend : public TBMEnv
40 void TBMBackend::SetUp()
45 void TBMBackend::TearDown()
50 // bufmgr init, deinit
51 TEST_F(TBMBackend, BufmgrInitDeinit)
55 bufmgr = tbm_bufmgr_init(-1);
56 ASSERT_TRUE(bufmgr != NULL);
58 tbm_bufmgr_deinit(bufmgr);
61 // TODO: Checking the mandatory symbols of the backend module has to be done
62 // at hal-tbm-api or at the tbm_module of libtbm.
64 // backend symbol check
65 TEST_F(TBMBackend, BufmgrCheckSymbols)
69 bufmgr = tbm_bufmgr_init(-1);
70 ASSERT_TRUE(bufmgr != NULL);
72 // check backend symbols
73 if (bufmgr->use_hal_tbm) {
74 printf("use_hal_tbm do not check backend symbol.\n");
75 } else if (bufmgr->backend_module_data) {
76 EXPECT_TRUE(bufmgr->backend_module_data->init);
77 EXPECT_TRUE(bufmgr->backend_module_data->deinit);
79 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_capabilities);
80 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_bind_native_display);
81 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_supported_formats);
82 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_plane_data);
83 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_alloc_bo);
84 if (!bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format)
85 printf("No bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format symbole.\n");
86 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_fd);
87 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_key);
89 EXPECT_TRUE(bufmgr->bo_func->bo_free);
90 EXPECT_TRUE(bufmgr->bo_func->bo_get_size);
91 EXPECT_TRUE(bufmgr->bo_func->bo_get_memory_types);
92 EXPECT_TRUE(bufmgr->bo_func->bo_get_handle);
93 EXPECT_TRUE(bufmgr->bo_func->bo_map);
94 EXPECT_TRUE(bufmgr->bo_func->bo_unmap);
95 if (!bufmgr->bo_func->bo_lock)
96 printf("No bufmgr->bo_func->bo_lock symbole.\n");
97 if (!bufmgr->bo_func->bo_unlock)
98 printf("No bufmgr->bo_func->bo_unlock symbole.\n");
99 EXPECT_TRUE(bufmgr->bo_func->bo_export_fd);
100 EXPECT_TRUE(bufmgr->bo_func->bo_export_key);
102 EXPECT_TRUE(bufmgr->backend->priv);
103 EXPECT_TRUE(bufmgr->backend->bufmgr_deinit);
104 EXPECT_TRUE(bufmgr->backend->bufmgr_bind_native_display);
105 EXPECT_TRUE(bufmgr->backend->bo_alloc);
106 EXPECT_TRUE(bufmgr->backend->bo_free);
107 EXPECT_TRUE(bufmgr->backend->bo_size);
108 EXPECT_TRUE(bufmgr->backend->bo_get_flags);
109 EXPECT_TRUE(bufmgr->backend->bo_get_handle);
110 EXPECT_TRUE(bufmgr->backend->bo_map && bufmgr->backend->bo_unmap);
111 if (!bufmgr->backend->bo_lock)
112 printf("No bufmgr->backend->bo_lock symbole.\n");
113 if (!bufmgr->backend->bo_unlock)
114 printf("No bufmgr->backend->bo_unlock symbole.\n");
115 EXPECT_TRUE(bufmgr->backend->bo_import_fd && bufmgr->backend->bo_export_fd);
116 EXPECT_TRUE(bufmgr->backend->bo_import && bufmgr->backend->bo_export);
117 EXPECT_TRUE(bufmgr->backend->surface_supported_format);
118 if (!bufmgr->backend->surface_bo_alloc)
119 printf("No bufmgr->backend->surface_bo_alloc symbole.\n");
120 EXPECT_TRUE(bufmgr->backend->surface_get_plane_data);
123 tbm_bufmgr_deinit(bufmgr);
124 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
128 // bo_alloc, bo_free, bo_size test
129 TEST_F(TBMBackend, BufmgrBindNativeDisplay)
132 struct wl_display *native_display = NULL;
135 native_display = wl_display_create();
136 assert(native_display != NULL);
138 bufmgr = tbm_bufmgr_init(-1);
139 ASSERT_TRUE(bufmgr != NULL);
141 ret = wl_display_add_socket(native_display, "ut-tbm-socket");
142 EXPECT_TRUE(ret == 0);
144 ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
145 EXPECT_TRUE(ret == 1);
147 tbm_bufmgr_deinit(bufmgr);
149 wl_display_destroy(native_display);
150 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
153 // bo_alloc, bo_free, bo_size test
154 TEST_F(TBMBackend, BoAllocFree)
157 tbm_bo bo[UT_TBM_ITER_COUNT];
158 int i, alloc_size, ret_size;
160 bufmgr = tbm_bufmgr_init(-1);
161 ASSERT_TRUE(bufmgr != NULL);
163 // bufmgr->backend->bo_alloc
164 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
165 alloc_size = 10 * i + 1;
166 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
167 EXPECT_TRUE(bo[i] != NULL);
169 // bufmgr->backend->bo_size
170 ret_size = tbm_bo_size(bo[i]);
171 if (alloc_size != ret_size)
172 printf("The alloc_size is different from return value of the tbm_bo_size().");
175 // bufmgr->backend->bo_free
176 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
179 tbm_bufmgr_deinit(bufmgr);
180 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
183 // bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
184 TEST_F(TBMBackend, BoGetHandleMapUnmap)
187 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
188 tbm_bo bo[UT_TBM_ITER_COUNT];
189 int i, j, alloc_size, ret_size;
192 bufmgr = tbm_bufmgr_init(-1);
193 ASSERT_TRUE(bufmgr != NULL);
195 // bufmgr->backend->bo_alloc
196 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
197 alloc_size = 10 * i + 1;
198 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
199 EXPECT_TRUE(bo[i] != NULL);
201 // bufmgr->backend->bo_size
202 ret_size = tbm_bo_size(bo[i]);
203 if (alloc_size != ret_size)
204 printf("The alloc_size is different from return value of the tbm_bo_size().");
206 for (j = TBM_DEVICE_DEFAULT; j <= TBM_DEVICE_3D; j++) {
207 bo_handle[i] = tbm_bo_get_handle(bo[i], j);
208 EXPECT_TRUE(bo_handle[i].ptr != NULL);
209 bo_handle[i] = tbm_bo_map(bo[i], j, TBM_OPTION_READ|TBM_OPTION_WRITE);
210 EXPECT_TRUE(bo_handle[i].ptr != NULL);
211 ret = tbm_bo_unmap(bo[i]);
212 EXPECT_TRUE(ret == 1);
216 // bufmgr->backend->bo_free
217 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
220 tbm_bufmgr_deinit(bufmgr);
221 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
224 // bo_export_fd, bo_import_fd
225 TEST_F(TBMBackend, BoExportImportFd)
228 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
229 tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
230 tbm_bo bo[UT_TBM_ITER_COUNT];
231 tbm_bo import_bo[UT_TBM_ITER_COUNT];
232 tbm_fd fd[UT_TBM_ITER_COUNT];
235 bufmgr = tbm_bufmgr_init(-1);
236 ASSERT_TRUE(bufmgr != NULL);
238 // bufmgr->backend->bo_alloc
239 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
240 alloc_size = 10 * i + 1;
241 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
242 EXPECT_TRUE(bo[i] != NULL);
244 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
245 EXPECT_TRUE(bo_handle[i].ptr != NULL);
247 fd[i] = tbm_bo_export_fd(bo[i]);
248 EXPECT_TRUE(fd[i] >= 0);
250 import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
251 EXPECT_TRUE(import_bo[i] != NULL);
253 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
254 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
257 // bufmgr->backend->bo_free
258 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
261 tbm_bufmgr_deinit(bufmgr);
262 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
265 // bo_export, bo_import
266 TEST_F(TBMBackend, BoExportImport)
269 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
270 tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
271 tbm_bo bo[UT_TBM_ITER_COUNT];
272 tbm_bo import_bo[UT_TBM_ITER_COUNT];
273 tbm_key key[UT_TBM_ITER_COUNT];
276 bufmgr = tbm_bufmgr_init(-1);
277 ASSERT_TRUE(bufmgr != NULL);
279 // bufmgr->backend->bo_alloc
280 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
281 alloc_size = 10 * i + 1;
282 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
283 EXPECT_TRUE(bo[i] != NULL);
285 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
286 EXPECT_TRUE(bo_handle[i].ptr != NULL);
288 key[i] = tbm_bo_export(bo[i]);
289 EXPECT_TRUE(key[i] != 0);
291 import_bo[i] = tbm_bo_import(bufmgr, key[i]);
292 EXPECT_TRUE(import_bo[i] != NULL);
294 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
295 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
298 // bufmgr->backend->bo_free
299 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
302 tbm_bufmgr_deinit(bufmgr);
303 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
306 // surface_supported_format
307 TEST_F(TBMBackend, SurfaceSupportedFormat)
309 uint32_t num_formats = 0;
310 tbm_format *formats = NULL;
314 ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
315 EXPECT_TRUE(ret == 1);
316 EXPECT_TRUE(formats != NULL);
318 for (uint32_t i = 0; i < num_formats; i++)
319 if (formats[i] == TBM_FORMAT_ARGB8888)
320 format = TBM_FORMAT_ARGB8888;
322 /* fail if there is no TBM_FORMAT_ARGB8888 format */
323 EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
327 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
330 // surface_bo_alloc, surface_get_plane_data
331 TEST_F(TBMBackend, SurfaceBoAlloc)
333 uint32_t num_formats = 0;
334 tbm_format *formats = NULL;
336 tbm_surface_h surface;
338 ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
339 EXPECT_TRUE(ret == 1);
340 EXPECT_TRUE(formats != NULL);
342 for (uint32_t i = 0; i < num_formats; i++) {
343 surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
344 EXPECT_TRUE(surface != NULL);
345 tbm_surface_internal_destroy(surface);
350 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);