haltests/src/tc_tdm_layer.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
   7  * Contact: Roman Marchenko <r.marchenko@samsung.com>
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sub license, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice (including the
  18  * next paragraph) shall be included in all copies or substantial portions
  19  * of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  *
  29 **************************************************************************/
  30
  31 #include "tc_tdm.h"
  32
  33 /* LCOV_EXCL_START */
  34
  35 #define BORDER_SIZE   20
  36
  37 class TDMLayer : public TDMOutput
  38 {
  39 public:
  40         bool has_layers;
  41         tdm_layer **layers;
  42         int layer_count;
  43
  44         tbm_surface_h buffers[3];
  45         tbm_surface_queue_h buffer_queue;
  46
  47         TDMLayer();
  48         void SetUp(void);
  49         void TearDown(void);
  50
  51         void DestroyBuffers(void);
  52 };
  53
  54 TDMLayer::TDMLayer()
  55 {
  56         has_layers = false;
  57         layers = NULL;
  58         layer_count = TDM_UT_INVALID_VALUE;
  59
  60         for (int b = 0; b < 3; b++)
  61                 buffers[b] = NULL;
  62
  63         buffer_queue = NULL;
  64 }
  65
  66 void TDMLayer::SetUp(void)
  67 {
  68         TDMOutput::SetUp();
  69
  70         layer_count = 0;
  71
  72         for (int o = 0; o < output_count; o++) {
  73                 int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
  74                 tdm_error ret;
  75
  76                 if (tc_tdm_output_is_hwc_enable(outputs[o]))
  77                         continue;
  78
  79                 EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
  80                 EXPECT_GT(count, 0);
  81
  82                 layer_count += count;
  83                 layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count);
  84                 EXPECT_NE(layers, NULL);
  85
  86                 for (int l = 0; l < count; l++) {
  87                         tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
  88                         EXPECT_NE(layer, NULL);
  89                         EXPECT_EQ(ret, TDM_ERROR_NONE);
  90                         layers[old_layer_count + l] = layer;
  91                 }
  92         }
  93
  94         if (layer_count > 0)
  95                 has_layers = true;
  96 }
  97
  98 void TDMLayer::TearDown(void)
  99 {
 100         for (int l = 0; l < layer_count; l++) {
 101                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 102         }
 103
 104         free(layers);
 105
 106         DestroyBuffers();
 107
 108         TDMOutput::TearDown();
 109 }
 110
 111 void TDMLayer::DestroyBuffers(void)
 112 {
 113         for (int b = 0; b < 3; b++) {
 114                 if (buffers[b]) {
 115                         tbm_surface_destroy(buffers[b]);
 116                         buffers[b] = NULL;
 117                 }
 118         }
 119
 120         if (buffer_queue) {
 121                 tbm_surface_queue_destroy(buffer_queue);
 122                 buffer_queue = NULL;
 123         }
 124 }
 125
 126 bool
 127 tc_tdm_layer_is_cursor_layer(tdm_layer *layer)
 128 {
 129         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 130         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 131                 return false;
 132         return capabilities & TDM_LAYER_CAPABILITY_CURSOR;
 133 }
 134
 135 bool
 136 tc_tdm_layer_is_primary_layer(tdm_layer *layer)
 137 {
 138         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 139         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 140                 return false;
 141         return capabilities & TDM_LAYER_CAPABILITY_PRIMARY;
 142 }
 143
 144 bool
 145 tc_tdm_layer_is_video_layer(tdm_layer *layer)
 146 {
 147         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 148         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 149                 return false;
 150         return capabilities & TDM_LAYER_CAPABILITY_VIDEO;
 151 }
 152
 153 bool
 154 tc_tdm_layer_support_scale(tdm_layer *layer)
 155 {
 156         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 157         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 158                 return false;
 159         return capabilities & TDM_LAYER_CAPABILITY_SCALE;
 160 }
 161
 162 bool
 163 tc_tdm_layer_support_no_crop(tdm_layer *layer)
 164 {
 165         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 166         if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
 167                 return false;
 168         return capabilities & TDM_LAYER_CAPABILITY_NO_CROP;
 169 }
 170
 171 unsigned int
 172 tc_tdm_layer_get_output_pipe(tdm_layer *layer)
 173 {
 174         unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
 175         tdm_error ret;
 176         tdm_output *output = tdm_layer_get_output(layer, &ret);
 177         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 178         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 179
 180         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
 181         TDM_UT_RETURN_FALSE_IF_FAIL(pipe != (unsigned int)TDM_UT_INVALID_VALUE);
 182
 183         return pipe;
 184 }
 185
 186 tbm_format
 187 tc_tdm_layer_find_best_format(tdm_layer *layer)
 188 {
 189         const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 190         int count = TDM_UT_INVALID_VALUE;
 191         tdm_error ret;
 192         ret = tdm_layer_get_available_formats(layer, &formats, &count);
 193         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 194
 195         for (int f = 0; f < count; f++)
 196                 if (formats[f] == TBM_FORMAT_ARGB8888)
 197                         return TBM_FORMAT_ARGB8888;
 198         for (int f = 0; f < count; f++)
 199                 if (formats[f] == TBM_FORMAT_XRGB8888)
 200                         return TBM_FORMAT_XRGB8888;
 201         for (int f = 0; f < count; f++)
 202                 if (formats[f] == TBM_FORMAT_YUV420)
 203                         return TBM_FORMAT_YUV420;
 204         for (int f = 0; f < count; f++)
 205                 if (formats[f] == TBM_FORMAT_NV12)
 206                         return TBM_FORMAT_NV12;
 207
 208         return 0;
 209 }
 210
 211 bool
 212 tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill)
 213 {
 214         tdm_error ret;
 215         unsigned int flags = 0;
 216         tbm_format format = (tbm_format)0;
 217         int w, h;
 218         tdm_output *output;
 219         const tdm_output_mode *mode = NULL;
 220
 221         /* create buffers */
 222         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
 223
 224         format = tc_tdm_layer_find_best_format(layer);
 225         TDM_UT_RETURN_FALSE_IF_FAIL(format != 0);
 226
 227         output = tdm_layer_get_output(layer, &ret);
 228         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 229         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 230
 231         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 232         TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 233
 234         if (tc_tdm_layer_is_primary_layer(layer)) {
 235                 w = mode->hdisplay;
 236                 h = mode->vdisplay;
 237         } else {
 238                 w = mode->hdisplay / 2;
 239                 h = mode->vdisplay / 2;
 240         }
 241
 242         TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
 243
 244         TDM_INFO("preparing buffers done");
 245
 246         return true;
 247 }
 248
 249 bool
 250 tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
 251 {
 252         tdm_error ret;
 253         unsigned int flags = 0;
 254         tbm_format format = (tbm_format)0;
 255         int w, h;
 256
 257         /* create buffers */
 258         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
 259
 260         format = tc_tdm_layer_find_best_format(layer);
 261         TDM_UT_RETURN_FALSE_IF_FAIL(format != (tbm_format)0);
 262
 263         if (tc_tdm_layer_is_primary_layer(layer)) {
 264                 tdm_output *output;
 265                 const tdm_output_mode *mode = NULL;
 266                 output = tdm_layer_get_output(layer, &ret);
 267                 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 268                 TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 269
 270                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 271                 TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 272
 273                 w = mode->hdisplay;
 274                 h = mode->vdisplay;
 275         } else {
 276                 w = TDM_UT_BUFFER_SIZE;
 277                 h = TDM_UT_BUFFER_SIZE;
 278         }
 279
 280         *buffer_queue = tbm_surface_queue_create(2, w, h, format, flags | TBM_BO_SCANOUT);
 281         TDM_UT_RETURN_FALSE_IF_FAIL((*buffer_queue) != NULL);
 282
 283         TDM_INFO("preparing buffers done");
 284
 285         return true;
 286 }
 287
 288 bool
 289 tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info)
 290 {
 291         tdm_error ret;
 292         tdm_output *output;
 293         const tdm_output_mode *mode = NULL;
 294         int count = 0;
 295         int zpos = -1;
 296         int bw, bh;
 297         int w, h;
 298         tbm_format format;
 299
 300         output = tdm_layer_get_output(layer, &ret);
 301         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 302         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 303
 304         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
 305         TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
 306
 307         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
 308         TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
 309
 310         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(layer, &zpos) == TDM_ERROR_NONE);
 311         TDM_UT_RETURN_FALSE_IF_FAIL(zpos >= 0);
 312
 313         if (buffer) {
 314                 tdm_helper_get_buffer_full_size(buffer, &bw, &bh);
 315                 w = tbm_surface_get_width(buffer);
 316                 h = tbm_surface_get_height(buffer);
 317                 format = tbm_surface_get_format(buffer);
 318         } else if (buffer_queue) {
 319                 bw = w = tbm_surface_queue_get_width(buffer_queue);
 320                 bh = h = tbm_surface_queue_get_height(buffer_queue);
 321                 format = tbm_surface_queue_get_format(buffer_queue);
 322         } else {
 323                 bw = mode->hdisplay;
 324                 bh = mode->vdisplay;
 325                 w = mode->hdisplay;
 326                 h = mode->vdisplay;
 327                 format = tc_tdm_layer_find_best_format(layer);
 328         }
 329
 330         /* TODO: check min,max,prefered size and avaiable formats */
 331         memset(info, 0, sizeof *info);
 332         info->src_config.size.h = bw;
 333         info->src_config.size.v = bh;
 334         info->src_config.pos.x = 0;
 335         info->src_config.pos.y = 0;
 336         info->src_config.pos.w = w;
 337         info->src_config.pos.h = h;
 338         info->src_config.format = format;
 339         if (tc_tdm_layer_is_primary_layer(layer)) {
 340                 info->dst_pos.x = 0;
 341                 info->dst_pos.y = 0;
 342         } else {
 343                 int x = (((int)mode->hdisplay - 2 * BORDER_SIZE - w) / count) * zpos + BORDER_SIZE;
 344                 int y = (((int)mode->vdisplay - 2 * BORDER_SIZE - h) / count) * zpos + BORDER_SIZE;
 345                 x = (x > 0) ? x : 0;
 346                 y = (y > 0) ? y : 0;
 347                 info->dst_pos.x = ((x + w) <= (int)mode->hdisplay) ? x : 0;
 348                 info->dst_pos.y = ((y + h) <= (int)mode->vdisplay) ? y : 0;
 349         }
 350         info->dst_pos.w = w;
 351         info->dst_pos.h = h;
 352         info->transform = TDM_TRANSFORM_NORMAL;
 353
 354         return true;
 355 }
 356
 357 bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 358 {
 359         return tc_tdm_layer_set_buffer_with_pos(layer, buffer, NULL);
 360 }
 361
 362 bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos)
 363 {
 364         tdm_info_layer old_info, info;
 365
 366         TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
 367
 368         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
 369         TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
 370
 371         if (pos) {
 372                 info.dst_pos.x = pos->x;
 373                 info.dst_pos.y = pos->y;
 374                 TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.w = pos->w);
 375                 TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.h = pos->h);
 376         }
 377
 378         if (memcmp(&old_info, &info, sizeof info)) {
 379                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
 380
 381                 tdm_output *output;
 382                 tdm_error ret;
 383                 int index = -1;
 384                 unsigned int pipe = 0;
 385                 output = tdm_layer_get_output(layer, &ret);
 386                 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 387                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_index(layer, &index) == TDM_ERROR_NONE);
 388                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
 389                 TDM_INFO("filling output(%d) layer(%d) info done: src_config(%dx%d: %d,%d %dx%d: %c%c%c%c) dst_pos(%d,%d %dx%d) transform(%s)",
 390                                  pipe, index,
 391                                  info.src_config.size.h, info.src_config.size.v,
 392                                  info.src_config.pos.x, info.src_config.pos.y, info.src_config.pos.w, info.src_config.pos.h,
 393                                  FOURCC_STR(info.src_config.format),
 394                                  info.dst_pos.x, info.dst_pos.y, info.dst_pos.w, info.dst_pos.h,
 395                                  tdm_transform_str(info.transform));
 396         }
 397
 398         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE);
 399
 400         return true;
 401 }
 402
 403 bool tc_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
 404 {
 405         tdm_info_layer old_info, info;
 406
 407         TDM_UT_RETURN_FALSE_IF_FAIL(buffer_queue != NULL);
 408
 409         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
 410         TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true);
 411
 412         if (memcmp(&old_info, &info, sizeof info))
 413                 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
 414
 415         TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer_queue(layer, buffer_queue) == TDM_ERROR_NONE);
 416
 417         return true;
 418 }
 419
 420 bool tc_tdm_layer_is_avaiable(tdm_layer *layer)
 421 {
 422         tdm_error ret;
 423         tdm_output *output = tdm_layer_get_output(layer, &ret);
 424         TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
 425         TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
 426
 427         /* only check if connected */
 428         return tc_tdm_output_is_connected(output);
 429 }
 430
 431 TEST_P(TDMLayer, LayerGetOutput)
 432 {
 433         TDM_UT_SKIP_FLAG(has_layers);
 434
 435         for (int l = 0; l < layer_count; l++) {
 436                 tdm_error ret;
 437                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
 438                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 439                 EXPECT_NE(output, NULL);
 440         }
 441 }
 442
 443 TEST_P(TDMLayer, LayerGetOutputNullObject)
 444 {
 445         TDM_UT_SKIP_FLAG(has_layers);
 446
 447         tdm_error ret;
 448         tdm_output *output = tdm_layer_get_output(NULL, &ret);
 449         EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
 450         EXPECT_EQ(output, NULL);
 451 }
 452
 453 TEST_P(TDMLayer, LayerGetOutputNullParam)
 454 {
 455         TDM_UT_SKIP_FLAG(has_layers);
 456
 457         for (int l = 0; l < layer_count; l++) {
 458                 tdm_output *output = tdm_layer_get_output(layers[l], NULL);
 459                 EXPECT_NE(output, NULL);
 460         }
 461 }
 462
 463 TEST_P(TDMLayer, LayerGetCapabilities)
 464 {
 465         TDM_UT_SKIP_FLAG(has_layers);
 466
 467         for (int l = 0; l < layer_count; l++) {
 468                 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 469                 EXPECT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
 470                 EXPECT_NE(capabilities, TDM_UT_INVALID_VALUE);
 471         }
 472 }
 473
 474 TEST_P(TDMLayer, LayerGetCapabilitiesNullObject)
 475 {
 476         TDM_UT_SKIP_FLAG(has_layers);
 477
 478         tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
 479         EXPECT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
 480         EXPECT_EQ(capabilities, TDM_UT_INVALID_VALUE);
 481 }
 482
 483 TEST_P(TDMLayer, LayerGetCapabilitiesNullOther)
 484 {
 485         TDM_UT_SKIP_FLAG(has_layers);
 486         EXPECT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 487 }
 488
 489 TEST_P(TDMLayer, LayerGetAvailableFormats)
 490 {
 491         TDM_UT_SKIP_FLAG(has_layers);
 492
 493         for (int l = 0; l < layer_count; l++) {
 494                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 495                         continue;
 496                 const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 497                 int count = TDM_UT_INVALID_VALUE;
 498                 EXPECT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
 499                 EXPECT_NE(formats, NULL);
 500                 EXPECT_GT(count, 0);
 501         }
 502 }
 503
 504 TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject)
 505 {
 506         TDM_UT_SKIP_FLAG(has_layers);
 507
 508         const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
 509         int count = TDM_UT_INVALID_VALUE;
 510         EXPECT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
 511         EXPECT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
 512         EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
 513 }
 514
 515 TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
 516 {
 517         TDM_UT_SKIP_FLAG(has_layers);
 518         if (!tc_tdm_layer_is_avaiable(layers[0]))
 519                 return;
 520         EXPECT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 521 }
 522
 523 TEST_P(TDMLayer, LayerGetAvailableProperties)
 524 {
 525         TDM_UT_SKIP_FLAG(has_layers);
 526
 527         for (int l = 0; l < layer_count; l++) {
 528                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 529                         continue;
 530                 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 531                 int count = TDM_UT_INVALID_VALUE;
 532                 EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
 533                 EXPECT_GE(count, 0);
 534                 if (count > 0)
 535                         EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
 536         }
 537 }
 538
 539 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullObject)
 540 {
 541         TDM_UT_SKIP_FLAG(has_layers);
 542
 543         const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 544         int count = TDM_UT_INVALID_VALUE;
 545         EXPECT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
 546         EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
 547         EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
 548 }
 549
 550 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther)
 551 {
 552         TDM_UT_SKIP_FLAG(has_layers);
 553
 554         EXPECT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
 555 }
 556
 557 TEST_P(TDMLayer, LayerGetZpos)
 558 {
 559         TDM_UT_SKIP_FLAG(has_layers);
 560
 561         bool *check_table = (bool*)calloc(layer_count, output_count);
 562         EXPECT_NE(check_table, NULL);
 563
 564         for (int l = 0; l < layer_count; l++) {
 565                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 566                         continue;
 567                 unsigned int pipe = tc_tdm_layer_get_output_pipe(layers[l]);
 568                 int zpos = TDM_UT_INVALID_VALUE;
 569                 EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE);
 570                 EXPECT_TRUE(zpos != TDM_UT_INVALID_VALUE);
 571                 if (tc_tdm_layer_is_video_layer(layers[l]))
 572                         continue;
 573                 EXPECT_TRUE(zpos >= 0);
 574                 EXPECT_TRUE(pipe < (unsigned int)output_count);
 575                 EXPECT_TRUE(*(check_table + pipe * layer_count + zpos) == false);
 576                 *(check_table + pipe * layer_count + zpos) = true;
 577         }
 578
 579         free(check_table);
 580 }
 581
 582 TEST_P(TDMLayer, LayerGetZposNullObject)
 583 {
 584         TDM_UT_SKIP_FLAG(has_layers);
 585
 586         int zpos = TDM_UT_INVALID_VALUE;
 587         EXPECT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
 588         EXPECT_EQ(zpos, TDM_UT_INVALID_VALUE);
 589 }
 590
 591 TEST_P(TDMLayer, LayerGetZposNullParam)
 592 {
 593         TDM_UT_SKIP_FLAG(has_layers);
 594
 595         EXPECT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 596 }
 597
 598 TEST_P(TDMLayer, DISABLED_LayerSetProperty)
 599 {
 600 }
 601
 602 TEST_P(TDMLayer, LayerSetPropertyNullObject)
 603 {
 604         tdm_value value = {.s32 = 0};
 605
 606         EXPECT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
 607 }
 608
 609 TEST_P(TDMLayer, LayerGetProperty)
 610 {
 611         TDM_UT_SKIP_FLAG(has_layers);
 612
 613         for (int l = 0; l < layer_count; l++) {
 614                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 615                         continue;
 616
 617                 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
 618                 int count = TDM_UT_INVALID_VALUE;
 619                 EXPECT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
 620                 EXPECT_GE(count, 0);
 621                 if (count > 0) {
 622                         EXPECT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
 623
 624                         for (int i = 0; i < count; i++) {
 625                                 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
 626                                 EXPECT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
 627                                 EXPECT_NE(value.s32, TDM_UT_INVALID_VALUE);
 628                         }
 629                 }
 630         }
 631 }
 632
 633 TEST_P(TDMLayer, LayerGetPropertyNullObject)
 634 {
 635         TDM_UT_SKIP_FLAG(has_layers);
 636
 637         tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
 638         EXPECT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
 639         EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
 640 }
 641
 642 TEST_P(TDMLayer, LayerGetPropertyNullOther)
 643 {
 644         TDM_UT_SKIP_FLAG(has_layers);
 645
 646         EXPECT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
 647 }
 648
 649 TEST_P(TDMLayer, LayerSetInfo)
 650 {
 651         TDM_UT_SKIP_FLAG(has_layers);
 652
 653         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 654
 655         for (int l = 0; l < layer_count; l++) {
 656                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 657                         continue;
 658
 659                 tdm_info_layer info;
 660                 EXPECT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
 661                 EXPECT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
 662         }
 663 }
 664
 665 TEST_P(TDMLayer, LayerSetInfoNullObject)
 666 {
 667         TDM_UT_SKIP_FLAG(has_layers);
 668
 669         tdm_info_layer info;
 670         memset(&info, 0, sizeof info);
 671         EXPECT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
 672 }
 673
 674 TEST_P(TDMLayer, LayerSetInfoNullOther)
 675 {
 676         TDM_UT_SKIP_FLAG(has_layers);
 677
 678         EXPECT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 679 }
 680
 681 TEST_P(TDMLayer, DISABLED_LayerGetInfo)
 682 {
 683 }
 684
 685 TEST_P(TDMLayer, LayerGetInfoNullObject)
 686 {
 687         TDM_UT_SKIP_FLAG(has_layers);
 688
 689         tdm_info_layer temp;
 690
 691         EXPECT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
 692 }
 693
 694 TEST_P(TDMLayer, LayerGetInfoNullParam)
 695 {
 696         TDM_UT_SKIP_FLAG(has_layers);
 697
 698         EXPECT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 699 }
 700
 701 TEST_P(TDMLayer, LayerGetBufferFlags)
 702 {
 703         TDM_UT_SKIP_FLAG(has_layers);
 704
 705         for (int l = 0; l < layer_count; l++) {
 706                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 707                         continue;
 708
 709                 unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
 710                 EXPECT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
 711                 EXPECT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
 712         }
 713 }
 714
 715 TEST_P(TDMLayer, LayerGetBufferFlagsNullObject)
 716 {
 717         TDM_UT_SKIP_FLAG(has_layers);
 718
 719         unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
 720         EXPECT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
 721         EXPECT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
 722 }
 723
 724 TEST_P(TDMLayer, LayerGetBufferFlagsNullOther)
 725 {
 726         TDM_UT_SKIP_FLAG(has_layers);
 727
 728         EXPECT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 729 }
 730
 731 static void
 732 _tc_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence,
 733                                                 unsigned int tv_sec, unsigned int tv_usec,
 734                                                 void *user_data)
 735 {
 736         bool *done = (bool*)user_data;
 737         if (done)
 738                 *done = true;
 739 }
 740
 741 TEST_P(TDMLayer, LayerSetBuffer)
 742 {
 743         TDM_UT_SKIP_FLAG(has_layers);
 744
 745         tdm_error ret;
 746
 747         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 748
 749         for (int l = 0; l < layer_count; l++) {
 750                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 751                         continue;
 752
 753                 int next_buffer = 0;
 754
 755                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 756                         continue;
 757                 if (tc_tdm_layer_is_video_layer(layers[l]))
 758                         continue;
 759
 760                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 761
 762                 /* set buffer & commit for 100 times */
 763                 for (int t = 0; t < 10; t++) {
 764                         tbm_surface_h displaying_buffer = NULL;
 765                         EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
 766                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 767                         while (displaying_buffer != buffers[next_buffer]) {
 768                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 769                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
 770                                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 771                         }
 772                         next_buffer++;
 773                         if (next_buffer == 3)
 774                                 next_buffer = 0;
 775                 }
 776
 777                 DestroyBuffers();
 778         }
 779 }
 780
 781 TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit)
 782 {
 783         TDM_UT_SKIP_FLAG(has_layers);
 784
 785         tdm_error ret;
 786
 787         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 788
 789         for (int l = 0; l < layer_count; l++) {
 790                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 791                         continue;
 792
 793                 int next_buffer = 0;
 794
 795                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 796                         continue;
 797                 if (tc_tdm_layer_is_video_layer(layers[l]))
 798                         continue;
 799
 800                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 801
 802                 /* set buffer & commit for 10 times */
 803                 for (int t = 0; t < 10; t++) {
 804                         tbm_surface_h displaying_buffer = NULL;
 805                         EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 806                         if (next_buffer == 3)
 807                                 next_buffer = 0;
 808                         EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
 809                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 810                         while (displaying_buffer != buffers[next_buffer]) {
 811                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
 812                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
 813                                 EXPECT_EQ(ret, TDM_ERROR_NONE);
 814                         }
 815                         next_buffer++;
 816                         if (next_buffer == 3)
 817                                 next_buffer = 0;
 818                 }
 819
 820                 DestroyBuffers();
 821         }
 822 }
 823
 824 TEST_P(TDMLayer, LayerSetBufferNullObject)
 825 {
 826         TDM_UT_SKIP_FLAG(has_layers);
 827
 828         tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
 829         EXPECT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
 830 }
 831
 832 TEST_P(TDMLayer, LayerSetBufferNullOther)
 833 {
 834         TDM_UT_SKIP_FLAG(has_layers);
 835
 836         EXPECT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
 837 }
 838
 839 TEST_P(TDMLayer, LayerUnsetBuffer)
 840 {
 841         TDM_UT_SKIP_FLAG(has_layers);
 842
 843         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 844
 845         for (int l = 0; l < layer_count; l++) {
 846                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 847                         continue;
 848
 849                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 850         }
 851 }
 852
 853 TEST_P(TDMLayer, LayerUnsetBufferNullObject)
 854 {
 855         TDM_UT_SKIP_FLAG(has_layers);
 856
 857         EXPECT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
 858 }
 859
 860 TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit)
 861 {
 862         TDM_UT_SKIP_FLAG(has_layers);
 863
 864         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 865
 866         for (int l = 0; l < layer_count; l++) {
 867                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 868                         continue;
 869
 870                 int next_buffer = 0;
 871
 872                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 873                         continue;
 874                 if (tc_tdm_layer_is_video_layer(layers[l]))
 875                         continue;
 876                 if (tc_tdm_layer_is_primary_layer(layers[l]))
 877                         continue;
 878
 879                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 880
 881                 /* set buffer & commit for 10 times */
 882                 for (int t = 0; t < 10; t++) {
 883                         EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 884                         if (next_buffer == 3)
 885                                 next_buffer = 0;
 886                         EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 887                         if (next_buffer == 3)
 888                                 next_buffer = 0;
 889                 }
 890
 891                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 892
 893                 DestroyBuffers();
 894         }
 895 }
 896
 897 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit)
 898 {
 899         TDM_UT_SKIP_FLAG(has_layers);
 900
 901         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 902
 903         for (int l = 0; l < layer_count; l++) {
 904                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 905                         continue;
 906
 907                 int next_buffer = 0;
 908
 909                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 910                         continue;
 911                 if (tc_tdm_layer_is_video_layer(layers[l]))
 912                         continue;
 913                 if (tc_tdm_layer_is_primary_layer(layers[l]))
 914                         continue;
 915
 916                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 917
 918                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 919                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 920                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 921
 922                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 923
 924                 DestroyBuffers();
 925         }
 926 }
 927
 928 /* drmModePageFlip can't be done twice in a vblank */
 929 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit)
 930 {
 931         TDM_UT_SKIP_FLAG(has_layers);
 932
 933         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 934
 935         for (int l = 0; l < layer_count; l++) {
 936                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 937                         continue;
 938
 939                 int next_buffer = 0;
 940
 941                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 942                         continue;
 943                 if (tc_tdm_layer_is_video_layer(layers[l]))
 944                         continue;
 945                 if (tc_tdm_layer_is_primary_layer(layers[l]))
 946                         continue;
 947
 948                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 949
 950                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 951                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 952
 953                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 954                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 955
 956                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 957
 958                 DestroyBuffers();
 959         }
 960 }
 961
 962 /* drmModePageFlip can't be done twice in a vblank */
 963 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer)
 964 {
 965         TDM_UT_SKIP_FLAG(has_layers);
 966
 967         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
 968
 969         for (int l = 0; l < layer_count; l++) {
 970                 if (!tc_tdm_layer_is_avaiable(layers[l]))
 971                         continue;
 972
 973                 int next_buffer = 0;
 974
 975                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
 976                         continue;
 977                 if (tc_tdm_layer_is_video_layer(layers[l]))
 978                         continue;
 979                 if (tc_tdm_layer_is_primary_layer(layers[l]))
 980                         continue;
 981
 982                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
 983
 984                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 985                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 986
 987                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
 988                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
 989
 990                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
 991
 992                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
 993
 994                 DestroyBuffers();
 995         }
 996 }
 997
 998 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone)
 999 {
1000         TDM_UT_SKIP_FLAG(has_layers);
1001
1002         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1003
1004         for (int l = 0; l < layer_count; l++) {
1005                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1006                         continue;
1007
1008                 int next_buffer = 0;
1009                 bool done;
1010
1011                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1012                         continue;
1013                 if (tc_tdm_layer_is_video_layer(layers[l]))
1014                         continue;
1015                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1016                         continue;
1017
1018                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1019
1020                 /* set buffer & commit for 10 times */
1021                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1022                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1023
1024                 done = false;
1025                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1026                 while (!done) {
1027                         EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1028                 }
1029
1030                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1031
1032                 DestroyBuffers();
1033         }
1034 }
1035
1036 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit)
1037 {
1038         TDM_UT_SKIP_FLAG(has_layers);
1039
1040         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1041
1042         for (int l = 0; l < layer_count; l++) {
1043                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1044                         continue;
1045
1046                 int next_buffer = 0;
1047                 bool done;
1048
1049                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1050                         continue;
1051                 if (tc_tdm_layer_is_video_layer(layers[l]))
1052                         continue;
1053                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1054                         continue;
1055
1056                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1057
1058                 /* set buffer & commit for 10 times */
1059                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1060                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1061
1062                 done = false;
1063                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1064                 while (!done) {
1065                         EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1066                 }
1067
1068                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1069                 next_buffer = 0;
1070                 EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1071
1072                 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1073
1074                 DestroyBuffers();
1075         }
1076 }
1077
1078 TEST_P(TDMLayer, LayerCommitDPMSOff)
1079 {
1080         TDM_UT_SKIP_FLAG(has_layers);
1081
1082         tdm_error ret;
1083         tdm_output *output = tdm_layer_get_output(layers[0], &ret);
1084         EXPECT_EQ(ret, TDM_ERROR_NONE);
1085         EXPECT_NE(output, NULL);
1086
1087         if (!tc_tdm_output_is_connected(output))
1088                 return;
1089
1090         EXPECT_TRUE(tc_tdm_output_prepare(dpy, output, true) == true);
1091
1092         EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
1093
1094         EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF);
1095
1096         EXPECT_TRUE(tc_tdm_output_unset(dpy, output) == true);
1097 }
1098
1099 TEST_P(TDMLayer, LayerCommitNullObject)
1100 {
1101         TDM_UT_SKIP_FLAG(has_layers);
1102
1103         EXPECT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1104 }
1105
1106 TEST_P(TDMLayer, LayerCommitNullOther)
1107 {
1108         TDM_UT_SKIP_FLAG(has_layers);
1109
1110         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1111
1112         EXPECT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
1113 }
1114
1115 TEST_P(TDMLayer, LayerIsCommittingNullObject)
1116 {
1117         TDM_UT_SKIP_FLAG(has_layers);
1118
1119         unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE;
1120         EXPECT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
1121         EXPECT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
1122 }
1123
1124 TEST_P(TDMLayer, LayerIsCommittingNullOther)
1125 {
1126         TDM_UT_SKIP_FLAG(has_layers);
1127
1128         EXPECT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1129 }
1130
1131 TEST_P(TDMLayer, LayerRemoveCommitHandler)
1132 {
1133         TDM_UT_SKIP_FLAG(has_layers);
1134
1135         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1136
1137         for (int l = 0; l < layer_count; l++) {
1138                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1139                         continue;
1140
1141                 tdm_error ret;
1142                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1143                 EXPECT_EQ(ret, TDM_ERROR_NONE);
1144                 EXPECT_NE(output, NULL);
1145
1146                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1147                         continue;
1148                 if (tc_tdm_layer_is_video_layer(layers[l]))
1149                         continue;
1150                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1151                         continue;
1152
1153                 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
1154
1155                 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
1156
1157                 for (int t = 0; t < 10; t++) {
1158                         bool done1 = false, done2 = false, done3 = false;
1159                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1160                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1161                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1162                         EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1163                         while (!done1 || done2 || !done3) {
1164                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1165                         }
1166                 }
1167
1168                 DestroyBuffers();
1169         }
1170 }
1171
1172 TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData)
1173 {
1174         TDM_UT_SKIP_FLAG(has_layers);
1175
1176         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1177
1178         for (int l = 0; l < layer_count; l++) {
1179                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1180                         continue;
1181
1182                 tdm_error ret;
1183                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1184                 EXPECT_EQ(ret, TDM_ERROR_NONE);
1185                 EXPECT_NE(output, NULL);
1186
1187                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1188                         continue;
1189                 if (tc_tdm_layer_is_video_layer(layers[l]))
1190                         continue;
1191                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1192                         continue;
1193
1194                 for (int t = 0; t < 10; t++) {
1195                         bool done1 = false, done2 = false, done3 = false;
1196                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1197                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1198                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1199                         EXPECT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1200                         while (!done1 || !done2 || !done3) {
1201                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1202                         }
1203                 }
1204         }
1205 }
1206 static void
1207 _tc_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence,
1208                                                  unsigned int tv_sec, unsigned int tv_usec,
1209                                                  void *user_data)
1210 {
1211         bool *done = (bool*)user_data;
1212         if (done)
1213                 *done = true;
1214         EXPECT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
1215 }
1216
1217 TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
1218 {
1219         TDM_UT_SKIP_FLAG(has_layers);
1220
1221         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1222
1223         for (int l = 0; l < layer_count; l++) {
1224                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1225                         continue;
1226
1227                 tdm_error ret;
1228                 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1229                 EXPECT_EQ(ret, TDM_ERROR_NONE);
1230                 EXPECT_NE(output, NULL);
1231
1232                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1233                         continue;
1234                 if (tc_tdm_layer_is_video_layer(layers[l]))
1235                         continue;
1236                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1237                         continue;
1238
1239                 for (int t = 0; t < 10; t++) {
1240                         bool done1 = false, done2 = false, done3 = false;
1241                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
1242                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
1243                         EXPECT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
1244                         while (!done1 || !done2 || !done3) {
1245                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1246                         }
1247                 }
1248         }
1249 }
1250
1251 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject)
1252 {
1253         TDM_UT_SKIP_FLAG(has_layers);
1254
1255         EXPECT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1256 }
1257
1258 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
1259 {
1260         TDM_UT_SKIP_FLAG(has_layers);
1261
1262         EXPECT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
1263 }
1264
1265 TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject)
1266 {
1267         TDM_UT_SKIP_FLAG(has_layers);
1268
1269         tbm_surface_h displaying_buffer;
1270         tdm_error ret;
1271         displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret);
1272         EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1273         EXPECT_EQ(displaying_buffer, NULL);
1274 }
1275
1276 TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther)
1277 {
1278         TDM_UT_SKIP_FLAG(has_layers);
1279
1280         tbm_surface_h displaying_buffer;
1281         displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL);
1282         EXPECT_EQ(displaying_buffer, NULL);
1283 }
1284
1285 TEST_P(TDMLayer, LayerIsUsableNullObject)
1286 {
1287         TDM_UT_SKIP_FLAG(has_layers);
1288
1289         unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE;
1290         EXPECT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
1291         EXPECT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
1292 }
1293
1294 TEST_P(TDMLayer, LayerSetBufferQueue)
1295 {
1296         TDM_UT_SKIP_FLAG(has_layers);
1297
1298         tdm_error ret;
1299
1300         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1301
1302         for (int l = 0; l < layer_count; l++) {
1303                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1304                         continue;
1305
1306                 tbm_surface_h buffer;
1307                 tbm_surface_h displaying_buffer;
1308
1309                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1310                         continue;
1311                 if (tc_tdm_layer_is_video_layer(layers[l]))
1312                         continue;
1313                 if (tc_tdm_layer_is_primary_layer(layers[l]))
1314                         continue;
1315
1316                 EXPECT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
1317                 EXPECT_NE(buffer_queue, NULL);
1318
1319                 EXPECT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
1320
1321                 EXPECT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
1322
1323                 for (int t = 0; t < 10; t++) {
1324                         EXPECT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1325                         EXPECT_NE(buffer, NULL);
1326                         tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
1327                         EXPECT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1328
1329                         displaying_buffer = NULL;
1330                         while (displaying_buffer != buffer) {
1331                                 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1332                                 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
1333                                 EXPECT_EQ(ret, TDM_ERROR_NONE);
1334                         }
1335                 }
1336
1337                 EXPECT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
1338
1339                 DestroyBuffers();
1340         }
1341 }
1342
1343 TEST_P(TDMLayer, LayerSetBufferQueueTwice)
1344 {
1345         TDM_UT_SKIP_FLAG(has_layers);
1346
1347         tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1348
1349         for (int l = 0; l < layer_count; l++) {
1350                 tbm_surface_queue_h buffer_queue1 = NULL;
1351                 tbm_surface_queue_h buffer_queue2 = NULL;
1352
1353                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1354                         continue;
1355                 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1356                         continue;
1357                 if (tc_tdm_layer_is_video_layer(layers[l]))
1358                         continue;
1359
1360                 EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true);
1361                 EXPECT_TRUE(buffer_queue1 != NULL);
1362                 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue1) == TDM_ERROR_NONE);
1363
1364                 EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true);
1365                 EXPECT_TRUE(buffer_queue2 != NULL);
1366                 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue2) == TDM_ERROR_NONE);
1367
1368                 if (buffer_queue1)
1369                         tbm_surface_queue_destroy(buffer_queue1);
1370                 if (buffer_queue2)
1371                         tbm_surface_queue_destroy(buffer_queue2);
1372         }
1373 }
1374
1375 TEST_P(TDMLayer, LayerSetBufferQueueNullObject)
1376 {
1377         TDM_UT_SKIP_FLAG(has_layers);
1378
1379         tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE;
1380
1381         EXPECT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
1382 }
1383
1384 TEST_P(TDMLayer, LayerSetBufferQueueNullOther)
1385 {
1386         TDM_UT_SKIP_FLAG(has_layers);
1387
1388         EXPECT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1389 }
1390
1391 TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject)
1392 {
1393         TDM_UT_SKIP_FLAG(has_layers);
1394
1395         EXPECT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
1396 }
1397
1398 TEST_P(TDMLayer, LayerIsUsableNullOther)
1399 {
1400         TDM_UT_SKIP_FLAG(has_layers);
1401
1402         EXPECT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1403 }
1404
1405 TEST_P(TDMLayer, LayerSetVideoPos)
1406 {
1407         TDM_UT_SKIP_FLAG(has_layers);
1408
1409         for (int l = 0; l < layer_count; ++l) {
1410                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1411                         continue;
1412
1413                 if (!tc_tdm_layer_is_video_layer(layers[l]))
1414                         continue;
1415                 EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
1416         }
1417 }
1418
1419 TEST_P(TDMLayer, LayerSetVideoPosNullObject)
1420 {
1421         TDM_UT_SKIP_FLAG(has_layers);
1422
1423         EXPECT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
1424 }
1425
1426 TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer)
1427 {
1428         TDM_UT_SKIP_FLAG(has_layers);
1429
1430         for (int l = 0; l < layer_count; ++l) {
1431                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1432                         continue;
1433
1434                 if (tc_tdm_layer_is_video_layer(layers[l]))
1435                         continue;
1436
1437                 EXPECT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
1438         }
1439 }
1440
1441 TEST_P(TDMLayer, LayerCreateCapture)
1442 {
1443         TDM_UT_SKIP_FLAG(has_layers);
1444
1445         for (int l = 0; l < layer_count; ++l) {
1446                 tdm_error ret;
1447                 tdm_capture *capture;
1448
1449                 if (!tc_tdm_layer_is_avaiable(layers[l]))
1450                         continue;
1451
1452                 capture = tdm_layer_create_capture(layers[l], &ret);
1453                 if (ret == TDM_ERROR_NONE)
1454                         EXPECT_NE(capture, NULL);
1455         }
1456 }
1457
1458 TEST_P(TDMLayer, LayerCreateCaptureNullObject)
1459 {
1460         TDM_UT_SKIP_FLAG(has_layers);
1461
1462         tdm_error ret;
1463         tdm_capture *capture = tdm_layer_create_capture(NULL, &ret);
1464         EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1465         EXPECT_EQ(capture, NULL);
1466 }
1467
1468 #ifdef TDM_UT_TEST_WITH_PARAMS
1469 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1470                                                 TDMLayer,
1471                                                 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1472 #else
1473 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1474                                                 TDMLayer,
1475                                                 Values(TDM_DEFAULT_MODULE));
1476 #endif
1477
1478 /* LCOV_EXCL_END */