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->use_hal_tbm) {
  71                 printf("use_hal_tbm do not check backend symbol.\n");
  72         } else if (bufmgr->backend_module_data) {
  73                 EXPECT_TRUE(bufmgr->backend_module_data->init);
  74                 EXPECT_TRUE(bufmgr->backend_module_data->deinit);
  75
  76                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_capabilities);
  77                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_bind_native_display);
  78                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_supported_formats);
  79                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_get_plane_data);
  80                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_alloc_bo);
  81                 if (!bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format)
  82                         printf("No bufmgr->bufmgr_func->bufmgr_alloc_bo_with_format symbole.\n");
  83                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_fd);
  84                 EXPECT_TRUE(bufmgr->bufmgr_func->bufmgr_import_key);
  85
  86                 EXPECT_TRUE(bufmgr->bo_func->bo_free);
  87                 EXPECT_TRUE(bufmgr->bo_func->bo_get_size);
  88                 EXPECT_TRUE(bufmgr->bo_func->bo_get_memory_types);
  89                 EXPECT_TRUE(bufmgr->bo_func->bo_get_handle);
  90                 EXPECT_TRUE(bufmgr->bo_func->bo_map);
  91                 EXPECT_TRUE(bufmgr->bo_func->bo_unmap);
  92                 if (!bufmgr->bo_func->bo_lock)
  93                         printf("No bufmgr->bo_func->bo_lock symbole.\n");
  94                 if (!bufmgr->bo_func->bo_unlock)
  95                         printf("No bufmgr->bo_func->bo_unlock symbole.\n");
  96                 EXPECT_TRUE(bufmgr->bo_func->bo_export_fd);
  97                 EXPECT_TRUE(bufmgr->bo_func->bo_export_key);
  98         } else {
  99                 EXPECT_TRUE(bufmgr->backend->priv);
 100                 EXPECT_TRUE(bufmgr->backend->bufmgr_deinit);
 101                 EXPECT_TRUE(bufmgr->backend->bufmgr_bind_native_display);
 102                 EXPECT_TRUE(bufmgr->backend->bo_alloc);
 103                 EXPECT_TRUE(bufmgr->backend->bo_free);
 104                 EXPECT_TRUE(bufmgr->backend->bo_size);
 105                 EXPECT_TRUE(bufmgr->backend->bo_get_flags);
 106                 EXPECT_TRUE(bufmgr->backend->bo_get_handle);
 107                 EXPECT_TRUE(bufmgr->backend->bo_map && bufmgr->backend->bo_unmap);
 108                 if (!bufmgr->backend->bo_lock)
 109                         printf("No bufmgr->backend->bo_lock symbole.\n");
 110                 if (!bufmgr->backend->bo_unlock)
 111                         printf("No bufmgr->backend->bo_unlock symbole.\n");
 112                 EXPECT_TRUE(bufmgr->backend->bo_import_fd && bufmgr->backend->bo_export_fd);
 113                 EXPECT_TRUE(bufmgr->backend->bo_import && bufmgr->backend->bo_export);
 114                 EXPECT_TRUE(bufmgr->backend->surface_supported_format);
 115                 if (!bufmgr->backend->surface_bo_alloc)
 116                         printf("No bufmgr->backend->surface_bo_alloc symbole.\n");
 117                 EXPECT_TRUE(bufmgr->backend->surface_get_plane_data);
 118         }
 119
 120         tbm_bufmgr_deinit(bufmgr);
 121         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 122 }
 123
 124 // bo_alloc, bo_free, bo_size test
 125 TEST_F(TBMBackend, BufmgrBindNativeDisplay)
 126 {
 127         tbm_bufmgr bufmgr;
 128         struct wl_display *native_display = NULL;
 129         int ret;
 130
 131         native_display = wl_display_create();
 132         assert(native_display != NULL);
 133
 134         bufmgr = tbm_bufmgr_init(-1);
 135         ASSERT_TRUE(bufmgr != NULL);
 136
 137         ret = wl_display_add_socket(native_display, "ut-tbm-socket");
 138         EXPECT_TRUE(ret == 0);
 139
 140         ret = tbm_bufmgr_bind_native_display(bufmgr, (void *)native_display);
 141         EXPECT_TRUE(ret == 1);
 142
 143         tbm_bufmgr_deinit(bufmgr);
 144
 145         wl_display_destroy(native_display);
 146         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 147 }
 148
 149 // bo_alloc, bo_free, bo_size test
 150 TEST_F(TBMBackend, BoAllocFree)
 151 {
 152         tbm_bufmgr bufmgr;
 153         tbm_bo bo[UT_TBM_ITER_COUNT];
 154         int i, alloc_size, ret_size;
 155
 156         bufmgr = tbm_bufmgr_init(-1);
 157         ASSERT_TRUE(bufmgr != NULL);
 158
 159         // bufmgr->backend->bo_alloc
 160         for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
 161                 alloc_size = 10 * i + 1;
 162                 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
 163                 EXPECT_TRUE(bo[i] != NULL);
 164
 165                 // bufmgr->backend->bo_size
 166                 ret_size = tbm_bo_size(bo[i]);
 167                 if (alloc_size != ret_size)
 168                         printf("The alloc_size is different from return value of the tbm_bo_size().");
 169         }
 170
 171         // bufmgr->backend->bo_free
 172         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 173                 tbm_bo_unref(bo[i]);
 174
 175         tbm_bufmgr_deinit(bufmgr);
 176         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 177 }
 178
 179 // bo_get_handle, bo_map/bo_lock, bo_unmap/bo_unlock, test
 180 TEST_F(TBMBackend, BoGetHandleMapUnmap)
 181 {
 182         tbm_bufmgr bufmgr;
 183         tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
 184         tbm_bo bo[UT_TBM_ITER_COUNT];
 185         int i, j, alloc_size, ret_size;
 186         int ret = 0;
 187
 188         bufmgr = tbm_bufmgr_init(-1);
 189         ASSERT_TRUE(bufmgr != NULL);
 190
 191         // bufmgr->backend->bo_alloc
 192         for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
 193                 alloc_size = 10 * i + 1;
 194                 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
 195                 EXPECT_TRUE(bo[i] != NULL);
 196
 197                 // bufmgr->backend->bo_size
 198                 ret_size = tbm_bo_size(bo[i]);
 199                 if (alloc_size != ret_size)
 200                         printf("The alloc_size is different from return value of the tbm_bo_size().");
 201
 202                 for (j = TBM_DEVICE_DEFAULT; j <= TBM_DEVICE_3D; j++) {
 203                         bo_handle[i] = tbm_bo_get_handle(bo[i], j);
 204                         EXPECT_TRUE(bo_handle[i].ptr != NULL);
 205                         bo_handle[i] = tbm_bo_map(bo[i], j, TBM_OPTION_READ|TBM_OPTION_WRITE);
 206                         EXPECT_TRUE(bo_handle[i].ptr != NULL);
 207                         ret = tbm_bo_unmap(bo[i]);
 208                         EXPECT_TRUE(ret == 1);
 209                 }
 210         }
 211
 212         // bufmgr->backend->bo_free
 213         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 214                 tbm_bo_unref(bo[i]);
 215
 216         tbm_bufmgr_deinit(bufmgr);
 217         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 218 }
 219
 220 // bo_export_fd, bo_import_fd
 221 TEST_F(TBMBackend, BoExportImportFd)
 222 {
 223         tbm_bufmgr bufmgr;
 224         tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
 225         tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
 226         tbm_bo bo[UT_TBM_ITER_COUNT];
 227         tbm_bo import_bo[UT_TBM_ITER_COUNT];
 228         tbm_fd fd[UT_TBM_ITER_COUNT];
 229         int i, alloc_size;
 230
 231         bufmgr = tbm_bufmgr_init(-1);
 232         ASSERT_TRUE(bufmgr != NULL);
 233
 234         // bufmgr->backend->bo_alloc
 235         for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
 236                 alloc_size = 10 * i + 1;
 237                 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
 238                 EXPECT_TRUE(bo[i] != NULL);
 239
 240                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 241                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 242
 243                 fd[i] = tbm_bo_export_fd(bo[i]);
 244                 EXPECT_TRUE(fd[i] >= 0);
 245
 246                 import_bo[i] = tbm_bo_import_fd(bufmgr, fd[i]);
 247                 EXPECT_TRUE(import_bo[i] != NULL);
 248
 249                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 250                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 251         }
 252
 253         // bufmgr->backend->bo_free
 254         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 255                 tbm_bo_unref(bo[i]);
 256
 257         tbm_bufmgr_deinit(bufmgr);
 258         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 259 }
 260
 261 // bo_export, bo_import
 262 TEST_F(TBMBackend, BoExportImport)
 263 {
 264         tbm_bufmgr bufmgr;
 265         tbm_bo_handle bo_handle[UT_TBM_ITER_COUNT];
 266         tbm_bo_handle import_bo_handle[UT_TBM_ITER_COUNT];
 267         tbm_bo bo[UT_TBM_ITER_COUNT];
 268         tbm_bo import_bo[UT_TBM_ITER_COUNT];
 269         tbm_key key[UT_TBM_ITER_COUNT];
 270         int i, alloc_size;
 271
 272         bufmgr = tbm_bufmgr_init(-1);
 273         ASSERT_TRUE(bufmgr != NULL);
 274
 275         // bufmgr->backend->bo_alloc
 276         for (i = 0; i < UT_TBM_ITER_COUNT; i++) {
 277                 alloc_size = 10 * i + 1;
 278                 bo[i] = tbm_bo_alloc(bufmgr, alloc_size, TBM_BO_DEFAULT);
 279                 EXPECT_TRUE(bo[i] != NULL);
 280
 281                 bo_handle[i] = tbm_bo_get_handle(bo[i], TBM_DEVICE_CPU);
 282                 EXPECT_TRUE(bo_handle[i].ptr != NULL);
 283
 284                 key[i] = tbm_bo_export(bo[i]);
 285                 EXPECT_TRUE(key[i] != 0);
 286
 287                 import_bo[i] = tbm_bo_import(bufmgr, key[i]);
 288                 EXPECT_TRUE(import_bo[i] != NULL);
 289
 290                 import_bo_handle[i] = tbm_bo_get_handle(import_bo[i], TBM_DEVICE_CPU);
 291                 EXPECT_TRUE(import_bo_handle[i].ptr != NULL);
 292         }
 293
 294         // bufmgr->backend->bo_free
 295         for (i = 0; i < UT_TBM_ITER_COUNT; i++)
 296                 tbm_bo_unref(bo[i]);
 297
 298         tbm_bufmgr_deinit(bufmgr);
 299         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 300 }
 301
 302 // surface_supported_format
 303 TEST_F(TBMBackend, SurfaceSupportedFormat)
 304 {
 305         uint32_t num_formats = 0;
 306         tbm_format *formats = NULL;
 307         int format = -1;
 308         int ret = 0;
 309
 310         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 311         EXPECT_TRUE(ret == 1);
 312         EXPECT_TRUE(formats != NULL);
 313
 314         for (uint32_t i = 0; i < num_formats; i++)
 315                 if (formats[i] == TBM_FORMAT_ARGB8888)
 316                         format = TBM_FORMAT_ARGB8888;
 317
 318         /* fail if there is no TBM_FORMAT_ARGB8888 format */
 319         EXPECT_TRUE(format == TBM_FORMAT_ARGB8888);
 320
 321         free(formats);
 322
 323         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 324 }
 325
 326 // surface_bo_alloc, surface_get_plane_data
 327 TEST_F(TBMBackend, SurfaceBoAlloc)
 328 {
 329         uint32_t num_formats = 0;
 330         tbm_format *formats = NULL;
 331         int ret = 0;
 332         tbm_surface_h surface;
 333
 334         ret = tbm_surface_internal_query_supported_formats(&formats, &num_formats);
 335         EXPECT_TRUE(ret == 1);
 336         EXPECT_TRUE(formats != NULL);
 337
 338         for (uint32_t i = 0; i < num_formats; i++) {
 339                 surface = tbm_surface_internal_create_with_flags(720, 1024, formats[i], TBM_BO_DEFAULT);
 340                 EXPECT_TRUE(surface != NULL);
 341                 tbm_surface_internal_destroy(surface);
 342         }
 343
 344         free(formats);
 345
 346         ASSERT_TRUE(tbm_bufmgr_debug_get_ref_count() == 0);
 347 }
 348
 349
 350