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 // backend symbol check
  62 TEST_F(TBMBackend, BufmgrCheckSymbols)
  63 {
  64         tbm_bufmgr bufmgr;
  65
  66         bufmgr = tbm_bufmgr_init(-1);
  67         ASSERT_TRUE(bufmgr != NULL);
  68
  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);
  73
  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);
  83
  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);
  96         } else {
  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);
 116         }
 117
 118         tbm_bufmgr_deinit(bufmgr);
 119         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 120 }
 121
 122 // bo_alloc, bo_free, bo_size test
 123 TEST_F(TBMBackend, BufmgrBindNativeDisplay)
 124 {
 125         tbm_bufmgr bufmgr;
 126         struct wl_display *native_display = NULL;
 127         int ret;
 128
 129         native_display = wl_display_create();
 130         assert(native_display != NULL);
 131
 132         bufmgr = tbm_bufmgr_init(-1);
 133         ASSERT_TRUE(bufmgr != NULL);
 134
 135         ret = wl_display_add_socket(native_display, "ut-tbm-socket");
 136         EXPECT_TRUE(ret == 0);
 137
 138         ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
 139         EXPECT_TRUE(ret == 1);
 140
 141         tbm_bufmgr_deinit(bufmgr);
 142
 143         wl_display_destroy(native_display);
 144         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 145 }
 146
 147 // bo_alloc, bo_free, bo_size test
 148 TEST_F(TBMBackend, BoAllocFree)
 149 {
 150         tbm_bufmgr bufmgr;
 151         tbm_bo bo[UT_TBM_ITER_COUNT];
 152         int i, alloc_size, ret_size;
 153
 154         bufmgr = tbm_bufmgr_init(-1);
 155         ASSERT_TRUE(bufmgr != NULL);
 156
 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);
 162
 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().");
 167         }
 168
 169         // bufmgr->backend->bo_free
 170         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 171                 tbm_bo_unref(bo[i]);
 172
 173         tbm_bufmgr_deinit(bufmgr);
 174         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 175 }
 176
 177 // bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
 178 TEST_F(TBMBackend, BoGetHandleMapUnmap)
 179 {
 180         tbm_bufmgr bufmgr;
 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;
 184         int ret = 0;
 185
 186         bufmgr = tbm_bufmgr_init(-1);
 187         ASSERT_TRUE(bufmgr != NULL);
 188
 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);
 194
 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().");
 199
 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);
 207                 }
 208         }
 209
 210         // bufmgr->backend->bo_free
 211         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 212                 tbm_bo_unref(bo[i]);
 213
 214         tbm_bufmgr_deinit(bufmgr);
 215         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 216 }
 217
 218 // bo_export_fd, bo_import_fd
 219 TEST_F(TBMBackend, BoExportImportFd)
 220 {
 221         tbm_bufmgr bufmgr;
 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];
 227         int i, alloc_size;
 228
 229         bufmgr = tbm_bufmgr_init(-1);
 230         ASSERT_TRUE(bufmgr != NULL);
 231
 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);
 237
 238                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 239                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 240
 241                 fd[i] = tbm_bo_export_fd(bo[i]);
 242                 EXPECT_TRUE(fd[i] >= 0);
 243
 244                 import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
 245                 EXPECT_TRUE(import_bo[i] != NULL);
 246
 247                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 248                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 249         }
 250
 251         // bufmgr->backend->bo_free
 252         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 253                 tbm_bo_unref(bo[i]);
 254
 255         tbm_bufmgr_deinit(bufmgr);
 256         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 257 }
 258
 259 // bo_export, bo_import
 260 TEST_F(TBMBackend, BoExportImport)
 261 {
 262         tbm_bufmgr bufmgr;
 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];
 268         int i, alloc_size;
 269
 270         bufmgr = tbm_bufmgr_init(-1);
 271         ASSERT_TRUE(bufmgr != NULL);
 272
 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);
 278
 279                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 280                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 281
 282                 key[i] = tbm_bo_export(bo[i]);
 283                 EXPECT_TRUE(key[i] != 0);
 284
 285                 import_bo[i] = tbm_bo_import(bufmgr, key[i]);
 286                 EXPECT_TRUE(import_bo[i] != NULL);
 287
 288                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 289                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 290         }
 291
 292         // bufmgr->backend->bo_free
 293         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 294                 tbm_bo_unref(bo[i]);
 295
 296         tbm_bufmgr_deinit(bufmgr);
 297         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 298 }
 299
 300 // surface_supported_format
 301 TEST_F(TBMBackend, SurfaceSupportedFormat)
 302 {
 303         uint32_t num_formats = 0;
 304         tbm_format *formats = NULL;
 305         int format = -1;
 306         int ret = 0;
 307
 308         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 309         EXPECT_TRUE(ret == 1);
 310         EXPECT_TRUE(formats != NULL);
 311
 312         for (uint32_t i = 0; i < num_formats; i++)
 313                 if (formats[i] == TBM_FORMAT_ARGB8888)
 314                         format = TBM_FORMAT_ARGB8888;
 315
 316         /* fail if there is no TBM_FORMAT_ARGB8888 format */
 317         EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
 318
 319         free(formats);
 320
 321         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 322 }
 323
 324 // surface_bo_alloc, surface_get_plane_data
 325 TEST_F(TBMBackend, SurfaceBoAlloc)
 326 {
 327         uint32_t num_formats = 0;
 328         tbm_format *formats = NULL;
 329         int ret = 0;
 330         tbm_surface_h surface;
 331
 332         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 333         EXPECT_TRUE(ret == 1);
 334         EXPECT_TRUE(formats != NULL);
 335
 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);
 340         }
 341
 342         free(formats);
 343
 344         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 345 }
 346
 347
 348