haltests/tc_tbm_backend.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: SooChan Lim <sc1.lim@samsung.com>
   6  *
   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:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  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.
  26  *
  27 **************************************************************************/
  28
  29 #include "tc_tbm.h"
  30
  31 #define UT_TBM_ITER_COUNT 100
  32
  33 class TBMBackend : public TBMEnv
  34 {
  35 public:
  36         void SetUp(void);
  37         void TearDown(void);
  38 };
  39
  40 void TBMBackend::SetUp()
  41 {
  42         TBMEnv::SetUp();
  43 }
  44
  45 void TBMBackend::TearDown()
  46 {
  47         TBMEnv::TearDown();
  48 }
  49
  50 // bufmgr init, deinit
  51 TEST_F(TBMBackend, BufmgrInitDeinit)
  52 {
  53         tbm_bufmgr bufmgr;
  54
  55         bufmgr = tbm_bufmgr_init(-1);
  56         ASSERT_TRUE(bufmgr != NULL);
  57
  58         tbm_bufmgr_deinit(bufmgr);
  59 }
  60
  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.
  63 #if 0
  64 // backend symbol check
  65 TEST_F(TBMBackend, BufmgrCheckSymbols)
  66 {
  67         tbm_bufmgr bufmgr;
  68
  69         bufmgr = tbm_bufmgr_init(-1);
  70         ASSERT_TRUE(bufmgr != NULL);
  71
  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);
  78
  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);
  88
  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);
 101         } else {
 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);
 121         }
 122
 123         tbm_bufmgr_deinit(bufmgr);
 124         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 125 }
 126 #endif
 127
 128 // bo_alloc, bo_free, bo_size test
 129 TEST_F(TBMBackend, BufmgrBindNativeDisplay)
 130 {
 131         tbm_bufmgr bufmgr;
 132         struct wl_display *native_display = NULL;
 133         int ret;
 134
 135         native_display = wl_display_create();
 136         assert(native_display != NULL);
 137
 138         bufmgr = tbm_bufmgr_init(-1);
 139         ASSERT_TRUE(bufmgr != NULL);
 140
 141         ret = wl_display_add_socket(native_display, "ut-tbm-socket");
 142         EXPECT_TRUE(ret == 0);
 143
 144         ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
 145         EXPECT_TRUE(ret == 1);
 146
 147         tbm_bufmgr_deinit(bufmgr);
 148
 149         wl_display_destroy(native_display);
 150         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 151 }
 152
 153 // bo_alloc, bo_free, bo_size test
 154 TEST_F(TBMBackend, BoAllocFree)
 155 {
 156         tbm_bufmgr bufmgr;
 157         tbm_bo bo[UT_TBM_ITER_COUNT];
 158         int i, alloc_size, ret_size;
 159
 160         bufmgr = tbm_bufmgr_init(-1);
 161         ASSERT_TRUE(bufmgr != NULL);
 162
 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);
 168
 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().");
 173         }
 174
 175         // bufmgr->backend->bo_free
 176         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 177                 tbm_bo_unref(bo[i]);
 178
 179         tbm_bufmgr_deinit(bufmgr);
 180         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 181 }
 182
 183 // bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
 184 TEST_F(TBMBackend, BoGetHandleMapUnmap)
 185 {
 186         tbm_bufmgr bufmgr;
 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;
 190         int ret = 0;
 191
 192         bufmgr = tbm_bufmgr_init(-1);
 193         ASSERT_TRUE(bufmgr != NULL);
 194
 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);
 200
 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().");
 205
 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);
 213                 }
 214         }
 215
 216         // bufmgr->backend->bo_free
 217         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 218                 tbm_bo_unref(bo[i]);
 219
 220         tbm_bufmgr_deinit(bufmgr);
 221         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 222 }
 223
 224 // bo_export_fd, bo_import_fd
 225 TEST_F(TBMBackend, BoExportImportFd)
 226 {
 227         tbm_bufmgr bufmgr;
 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];
 233         int i, alloc_size;
 234
 235         bufmgr = tbm_bufmgr_init(-1);
 236         ASSERT_TRUE(bufmgr != NULL);
 237
 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);
 243
 244                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 245                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 246
 247                 fd[i] = tbm_bo_export_fd(bo[i]);
 248                 EXPECT_TRUE(fd[i] >= 0);
 249
 250                 import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
 251                 EXPECT_TRUE(import_bo[i] != NULL);
 252
 253                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 254                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 255         }
 256
 257         // bufmgr->backend->bo_free
 258         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 259                 tbm_bo_unref(bo[i]);
 260
 261         tbm_bufmgr_deinit(bufmgr);
 262         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 263 }
 264
 265 // bo_export, bo_import
 266 TEST_F(TBMBackend, BoExportImport)
 267 {
 268         tbm_bufmgr bufmgr;
 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];
 274         int i, alloc_size;
 275
 276         bufmgr = tbm_bufmgr_init(-1);
 277         ASSERT_TRUE(bufmgr != NULL);
 278
 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);
 284
 285                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 286                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 287
 288                 key[i] = tbm_bo_export(bo[i]);
 289                 EXPECT_TRUE(key[i] != 0);
 290
 291                 import_bo[i] = tbm_bo_import(bufmgr, key[i]);
 292                 EXPECT_TRUE(import_bo[i] != NULL);
 293
 294                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 295                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 296         }
 297
 298         // bufmgr->backend->bo_free
 299         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 300                 tbm_bo_unref(bo[i]);
 301
 302         tbm_bufmgr_deinit(bufmgr);
 303         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 304 }
 305
 306 // surface_supported_format
 307 TEST_F(TBMBackend, SurfaceSupportedFormat)
 308 {
 309         uint32_t num_formats = 0;
 310         tbm_format *formats = NULL;
 311         int format = -1;
 312         int ret = 0;
 313
 314         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 315         EXPECT_TRUE(ret == 1);
 316         EXPECT_TRUE(formats != NULL);
 317
 318         for (uint32_t i = 0; i < num_formats; i++)
 319                 if (formats[i] == TBM_FORMAT_ARGB8888)
 320                         format = TBM_FORMAT_ARGB8888;
 321
 322         /* fail if there is no TBM_FORMAT_ARGB8888 format */
 323         EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
 324
 325         free(formats);
 326
 327         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 328 }
 329
 330 // surface_bo_alloc, surface_get_plane_data
 331 TEST_F(TBMBackend, SurfaceBoAlloc)
 332 {
 333         uint32_t num_formats = 0;
 334         tbm_format *formats = NULL;
 335         int ret = 0;
 336         tbm_surface_h surface;
 337
 338         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 339         EXPECT_TRUE(ret == 1);
 340         EXPECT_TRUE(formats != NULL);
 341
 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);
 346         }
 347
 348         free(formats);
 349
 350         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 351 }
 352
 353
 354