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 // backend symbol check
62 TEST_F(TBMBackend, BufmgrCheckSymbols)
66 bufmgr = tbm_bufmgr_init(-1);
67 ASSERT_TRUE(bufmgr != NULL);
69 // check backend symbols
70 if (bufmgr->backend_module_data) {
71 EXPECT_TRUE(bufmgr->backend_module_data->init);
72 EXPECT_TRUE(bufmgr->backend_module_data->deinit);
74 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_capabilities);
75 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_bind_native_display);
76 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_supported_formats);
77 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_plane_data);
78 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_alloc_bo);
79 if (!bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format)
80 printf("No bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format symbole.\n");
81 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_fd);
82 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_key);
84 EXPECT_TRUE(bufmgr->bo_func->bo_free);
85 EXPECT_TRUE(bufmgr->bo_func->bo_get_size);
86 EXPECT_TRUE(bufmgr->bo_func->bo_get_memory_types);
87 EXPECT_TRUE(bufmgr->bo_func->bo_get_handle);
88 EXPECT_TRUE(bufmgr->bo_func->bo_map);
89 EXPECT_TRUE(bufmgr->bo_func->bo_unmap);
90 if (!bufmgr->bo_func->bo_lock)
91 printf("No bufmgr->bo_func->bo_lock symbole.\n");
92 if (!bufmgr->bo_func->bo_unlock)
93 printf("No bufmgr->bo_func->bo_unlock symbole.\n");
94 EXPECT_TRUE(bufmgr->bo_func->bo_export_fd);
95 EXPECT_TRUE(bufmgr->bo_func->bo_export_key);
97 EXPECT_TRUE(bufmgr->backend->priv);
98 EXPECT_TRUE(bufmgr->backend->bufmgr_deinit);
99 EXPECT_TRUE(bufmgr->backend->bufmgr_bind_native_display);
100 EXPECT_TRUE(bufmgr->backend->bo_alloc);
101 EXPECT_TRUE(bufmgr->backend->bo_free);
102 EXPECT_TRUE(bufmgr->backend->bo_size);
103 EXPECT_TRUE(bufmgr->backend->bo_get_flags);
104 EXPECT_TRUE(bufmgr->backend->bo_get_handle);
105 EXPECT_TRUE(bufmgr->backend->bo_map && bufmgr->backend->bo_unmap);
106 if (!bufmgr->backend->bo_lock)
107 printf("No bufmgr->backend->bo_lock symbole.\n");
108 if (!bufmgr->backend->bo_unlock)
109 printf("No bufmgr->backend->bo_unlock symbole.\n");
110 EXPECT_TRUE(bufmgr->backend->bo_import_fd && bufmgr->backend->bo_export_fd);
111 EXPECT_TRUE(bufmgr->backend->bo_import && bufmgr->backend->bo_export);
112 EXPECT_TRUE(bufmgr->backend->surface_supported_format);
113 if (!bufmgr->backend->surface_bo_alloc)
114 printf("No bufmgr->backend->surface_bo_alloc symbole.\n");
115 EXPECT_TRUE(bufmgr->backend->surface_get_plane_data);
118 tbm_bufmgr_deinit(bufmgr);
119 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
122 // bo_alloc, bo_free, bo_size test
123 TEST_F(TBMBackend, BufmgrBindNativeDisplay)
126 struct wl_display *native_display = NULL;
129 native_display = wl_display_create();
130 assert(native_display != NULL);
132 bufmgr = tbm_bufmgr_init(-1);
133 ASSERT_TRUE(bufmgr != NULL);
135 ret = wl_display_add_socket(native_display, "ut-tbm-socket");
136 EXPECT_TRUE(ret == 0);
138 ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
139 EXPECT_TRUE(ret == 1);
141 tbm_bufmgr_deinit(bufmgr);
143 wl_display_destroy(native_display);
144 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
147 // bo_alloc, bo_free, bo_size test
148 TEST_F(TBMBackend, BoAllocFree)
151 tbm_bo bo[UT_TBM_ITER_COUNT];
152 int i, alloc_size, ret_size;
154 bufmgr = tbm_bufmgr_init(-1);
155 ASSERT_TRUE(bufmgr != NULL);
157 // bufmgr->backend->bo_alloc
158 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
159 alloc_size = 10 * i + 1;
160 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
161 EXPECT_TRUE(bo[i] != NULL);
163 // bufmgr->backend->bo_size
164 ret_size = tbm_bo_size(bo[i]);
165 if (alloc_size != ret_size)
166 printf("The alloc_size is different from return value of the tbm_bo_size().");
169 // bufmgr->backend->bo_free
170 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
173 tbm_bufmgr_deinit(bufmgr);
174 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
177 // bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
178 TEST_F(TBMBackend, BoGetHandleMapUnmap)
181 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
182 tbm_bo bo[UT_TBM_ITER_COUNT];
183 int i, j, alloc_size, ret_size;
186 bufmgr = tbm_bufmgr_init(-1);
187 ASSERT_TRUE(bufmgr != NULL);
189 // bufmgr->backend->bo_alloc
190 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
191 alloc_size = 10 * i + 1;
192 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
193 EXPECT_TRUE(bo[i] != NULL);
195 // bufmgr->backend->bo_size
196 ret_size = tbm_bo_size(bo[i]);
197 if (alloc_size != ret_size)
198 printf("The alloc_size is different from return value of the tbm_bo_size().");
200 for (j = TBM_DEVICE_DEFAULT; j <= TBM_DEVICE_3D; j++) {
201 bo_handle[i] = tbm_bo_get_handle(bo[i], j);
202 EXPECT_TRUE(bo_handle[i].ptr != NULL);
203 bo_handle[i] = tbm_bo_map(bo[i], j, TBM_OPTION_READ|TBM_OPTION_WRITE);
204 EXPECT_TRUE(bo_handle[i].ptr != NULL);
205 ret = tbm_bo_unmap(bo[i]);
206 EXPECT_TRUE(ret == 1);
210 // bufmgr->backend->bo_free
211 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
214 tbm_bufmgr_deinit(bufmgr);
215 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
218 // bo_export_fd, bo_import_fd
219 TEST_F(TBMBackend, BoExportImportFd)
222 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
223 tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
224 tbm_bo bo[UT_TBM_ITER_COUNT];
225 tbm_bo import_bo[UT_TBM_ITER_COUNT];
226 tbm_fd fd[UT_TBM_ITER_COUNT];
229 bufmgr = tbm_bufmgr_init(-1);
230 ASSERT_TRUE(bufmgr != NULL);
232 // bufmgr->backend->bo_alloc
233 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
234 alloc_size = 10 * i + 1;
235 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
236 EXPECT_TRUE(bo[i] != NULL);
238 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
239 EXPECT_TRUE(bo_handle[i].ptr != NULL);
241 fd[i] = tbm_bo_export_fd(bo[i]);
242 EXPECT_TRUE(fd[i] >= 0);
244 import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
245 EXPECT_TRUE(import_bo[i] != NULL);
247 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
248 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
251 // bufmgr->backend->bo_free
252 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
255 tbm_bufmgr_deinit(bufmgr);
256 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
259 // bo_export, bo_import
260 TEST_F(TBMBackend, BoExportImport)
263 tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
264 tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
265 tbm_bo bo[UT_TBM_ITER_COUNT];
266 tbm_bo import_bo[UT_TBM_ITER_COUNT];
267 tbm_key key[UT_TBM_ITER_COUNT];
270 bufmgr = tbm_bufmgr_init(-1);
271 ASSERT_TRUE(bufmgr != NULL);
273 // bufmgr->backend->bo_alloc
274 for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
275 alloc_size = 10 * i + 1;
276 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
277 EXPECT_TRUE(bo[i] != NULL);
279 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
280 EXPECT_TRUE(bo_handle[i].ptr != NULL);
282 key[i] = tbm_bo_export(bo[i]);
283 EXPECT_TRUE(key[i] != 0);
285 import_bo[i] = tbm_bo_import(bufmgr, key[i]);
286 EXPECT_TRUE(import_bo[i] != NULL);
288 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
289 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
292 // bufmgr->backend->bo_free
293 for (i = 0; i < UT_TBM_ITER_COUNT; i++)
296 tbm_bufmgr_deinit(bufmgr);
297 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
300 // surface_supported_format
301 TEST_F(TBMBackend, SurfaceSupportedFormat)
303 uint32_t num_formats = 0;
304 tbm_format *formats = NULL;
308 ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
309 EXPECT_TRUE(ret == 1);
310 EXPECT_TRUE(formats != NULL);
312 for (uint32_t i = 0; i < num_formats; i++)
313 if (formats[i] == TBM_FORMAT_ARGB8888)
314 format = TBM_FORMAT_ARGB8888;
316 /* fail if there is no TBM_FORMAT_ARGB8888 format */
317 EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
321 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
324 // surface_bo_alloc, surface_get_plane_data
325 TEST_F(TBMBackend, SurfaceBoAlloc)
327 uint32_t num_formats = 0;
328 tbm_format *formats = NULL;
330 tbm_surface_h surface;
332 ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
333 EXPECT_TRUE(ret == 1);
334 EXPECT_TRUE(formats != NULL);
336 for (uint32_t i = 0; i < num_formats; i++) {
337 surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
338 EXPECT_TRUE(surface != NULL);
339 tbm_surface_internal_destroy(surface);
344 ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);