1 /**************************************************************************
3 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
6 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
7 * Contact: Roman Marchenko <r.marchenko@samsung.com>
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:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
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.
29 **************************************************************************/
35 #define BORDER_SIZE 20
37 class TDMLayer : public TDMOutput
44 tbm_surface_h buffers[3];
45 tbm_surface_queue_h buffer_queue;
51 void DestroyBuffers(void);
58 layer_count = TDM_UT_INVALID_VALUE;
60 for (int b = 0; b < 3; b++)
66 void TDMLayer::SetUp(void)
72 for (int o = 0; o < output_count; o++) {
73 int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
76 if (tc_tdm_output_is_hwc_enable(outputs[o]))
79 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
83 layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count);
84 ASSERT_NE(layers, NULL);
86 for (int l = 0; l < count; l++) {
87 tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
88 ASSERT_NE(layer, NULL);
89 ASSERT_EQ(ret, TDM_ERROR_NONE);
90 layers[old_layer_count + l] = layer;
98 void TDMLayer::TearDown(void)
100 for (int l = 0; l < layer_count; l++) {
101 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
108 TDMOutput::TearDown();
111 void TDMLayer::DestroyBuffers(void)
113 for (int b = 0; b < 3; b++) {
115 tbm_surface_destroy(buffers[b]);
121 tbm_surface_queue_destroy(buffer_queue);
127 tc_tdm_layer_is_cursor_layer(tdm_layer *layer)
129 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
130 if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
132 return capabilities & TDM_LAYER_CAPABILITY_CURSOR;
136 tc_tdm_layer_is_primary_layer(tdm_layer *layer)
138 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
139 if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
141 return capabilities & TDM_LAYER_CAPABILITY_PRIMARY;
145 tc_tdm_layer_is_video_layer(tdm_layer *layer)
147 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
148 if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
150 return capabilities & TDM_LAYER_CAPABILITY_VIDEO;
154 tc_tdm_layer_support_scale(tdm_layer *layer)
156 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
157 if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
159 return capabilities & TDM_LAYER_CAPABILITY_SCALE;
163 tc_tdm_layer_support_no_crop(tdm_layer *layer)
165 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
166 if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE)
168 return capabilities & TDM_LAYER_CAPABILITY_NO_CROP;
172 tc_tdm_layer_get_output_pipe(tdm_layer *layer)
174 unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
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);
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);
187 tc_tdm_layer_find_best_format(tdm_layer *layer)
189 const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
190 int count = TDM_UT_INVALID_VALUE;
192 ret = tdm_layer_get_available_formats(layer, &formats, &count);
193 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
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;
212 tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill)
215 unsigned int flags = 0;
216 tbm_format format = (tbm_format)0;
219 const tdm_output_mode *mode = NULL;
222 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
224 format = tc_tdm_layer_find_best_format(layer);
225 TDM_UT_RETURN_FALSE_IF_FAIL(format != 0);
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);
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);
234 if (tc_tdm_layer_is_primary_layer(layer)) {
238 w = mode->hdisplay / 2;
239 h = mode->vdisplay / 2;
242 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
244 TDM_INFO("preparing buffers done");
250 tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue)
253 unsigned int flags = 0;
254 tbm_format format = (tbm_format)0;
258 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE);
260 format = tc_tdm_layer_find_best_format(layer);
261 TDM_UT_RETURN_FALSE_IF_FAIL(format != (tbm_format)0);
263 if (tc_tdm_layer_is_primary_layer(layer)) {
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);
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);
276 w = TDM_UT_BUFFER_SIZE;
277 h = TDM_UT_BUFFER_SIZE;
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);
283 TDM_INFO("preparing buffers done");
289 tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info)
293 const tdm_output_mode *mode = NULL;
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);
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);
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);
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);
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);
327 format = tc_tdm_layer_find_best_format(layer);
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)) {
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;
347 info->dst_pos.x = ((x + w) <= (int)mode->hdisplay) ? x : 0;
348 info->dst_pos.y = ((y + h) <= (int)mode->vdisplay) ? y : 0;
352 info->transform = TDM_TRANSFORM_NORMAL;
357 bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
359 tdm_info_layer old_info, info;
361 TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
363 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
364 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
366 if (memcmp(&old_info, &info, sizeof info)) {
367 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
372 unsigned int pipe = 0;
373 output = tdm_layer_get_output(layer, &ret);
374 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
375 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_index(layer, &index) == TDM_ERROR_NONE);
376 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
377 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)",
379 info.src_config.size.h, info.src_config.size.v,
380 info.src_config.pos.x, info.src_config.pos.y, info.src_config.pos.w, info.src_config.pos.h,
381 FOURCC_STR(info.src_config.format),
382 info.dst_pos.x, info.dst_pos.y, info.dst_pos.w, info.dst_pos.h,
383 tdm_transform_str(info.transform));
386 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE);
391 bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos)
393 tdm_info_layer old_info, info;
395 TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
396 TDM_UT_RETURN_FALSE_IF_FAIL(pos != NULL);
398 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
399 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true);
401 info.dst_pos.x = pos->x;
402 info.dst_pos.y = pos->y;
403 TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.w = pos->w);
404 TDM_UT_RETURN_FALSE_IF_FAIL(info.dst_pos.h = pos->h);
406 if (memcmp(&old_info, &info, sizeof info)) {
407 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
412 unsigned int pipe = 0;
413 output = tdm_layer_get_output(layer, &ret);
414 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
415 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_index(layer, &index) == TDM_ERROR_NONE);
416 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
417 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)",
419 info.src_config.size.h, info.src_config.size.v,
420 info.src_config.pos.x, info.src_config.pos.y, info.src_config.pos.w, info.src_config.pos.h,
421 FOURCC_STR(info.src_config.format),
422 info.dst_pos.x, info.dst_pos.y, info.dst_pos.w, info.dst_pos.h,
423 tdm_transform_str(info.transform));
426 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer(layer, buffer) == TDM_ERROR_NONE);
431 bool tc_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
433 tdm_info_layer old_info, info;
435 TDM_UT_RETURN_FALSE_IF_FAIL(buffer_queue != NULL);
437 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE);
438 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true);
440 if (memcmp(&old_info, &info, sizeof info))
441 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE);
443 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_buffer_queue(layer, buffer_queue) == TDM_ERROR_NONE);
448 bool tc_tdm_layer_is_avaiable(tdm_layer *layer)
451 tdm_output *output = tdm_layer_get_output(layer, &ret);
452 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
453 TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL);
455 /* only check if connected */
456 return tc_tdm_output_is_connected(output);
459 TEST_P(TDMLayer, LayerGetOutput)
461 TDM_UT_SKIP_FLAG(has_layers);
463 for (int l = 0; l < layer_count; l++) {
465 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
466 ASSERT_EQ(ret, TDM_ERROR_NONE);
467 ASSERT_NE(output, NULL);
471 TEST_P(TDMLayer, LayerGetOutputNullObject)
473 TDM_UT_SKIP_FLAG(has_layers);
476 tdm_output *output = tdm_layer_get_output(NULL, &ret);
477 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
478 ASSERT_EQ(output, NULL);
481 TEST_P(TDMLayer, LayerGetOutputNullParam)
483 TDM_UT_SKIP_FLAG(has_layers);
485 for (int l = 0; l < layer_count; l++) {
486 tdm_output *output = tdm_layer_get_output(layers[l], NULL);
487 ASSERT_NE(output, NULL);
491 TEST_P(TDMLayer, LayerGetCapabilities)
493 TDM_UT_SKIP_FLAG(has_layers);
495 for (int l = 0; l < layer_count; l++) {
496 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
497 ASSERT_EQ(tdm_layer_get_capabilities(layers[l], &capabilities), TDM_ERROR_NONE);
498 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
502 TEST_P(TDMLayer, LayerGetCapabilitiesNullObject)
504 TDM_UT_SKIP_FLAG(has_layers);
506 tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE;
507 ASSERT_EQ(tdm_layer_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
508 ASSERT_EQ(capabilities, TDM_UT_INVALID_VALUE);
511 TEST_P(TDMLayer, LayerGetCapabilitiesNullOther)
513 TDM_UT_SKIP_FLAG(has_layers);
514 ASSERT_EQ(tdm_layer_get_capabilities(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
517 TEST_P(TDMLayer, LayerGetAvailableFormats)
519 TDM_UT_SKIP_FLAG(has_layers);
521 for (int l = 0; l < layer_count; l++) {
522 if (!tc_tdm_layer_is_avaiable(layers[l]))
524 const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
525 int count = TDM_UT_INVALID_VALUE;
526 ASSERT_EQ(tdm_layer_get_available_formats(layers[l], &formats, &count), TDM_ERROR_NONE);
527 ASSERT_NE(formats, NULL);
532 TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject)
534 TDM_UT_SKIP_FLAG(has_layers);
536 const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE;
537 int count = TDM_UT_INVALID_VALUE;
538 ASSERT_EQ(tdm_layer_get_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER);
539 ASSERT_EQ(formats, (const tbm_format *)TDM_UT_INVALID_VALUE);
540 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
543 TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther)
545 TDM_UT_SKIP_FLAG(has_layers);
546 if (!tc_tdm_layer_is_avaiable(layers[0]))
548 ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
551 TEST_P(TDMLayer, LayerGetAvailableProperties)
553 TDM_UT_SKIP_FLAG(has_layers);
555 for (int l = 0; l < layer_count; l++) {
556 if (!tc_tdm_layer_is_avaiable(layers[l]))
558 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
559 int count = TDM_UT_INVALID_VALUE;
560 ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
563 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
567 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullObject)
569 TDM_UT_SKIP_FLAG(has_layers);
571 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
572 int count = TDM_UT_INVALID_VALUE;
573 ASSERT_EQ(tdm_layer_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
574 ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
575 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
578 TEST_P(TDMLayer, LayerGetAvailablePropertiesNullOther)
580 TDM_UT_SKIP_FLAG(has_layers);
582 ASSERT_EQ(tdm_layer_get_available_properties(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
585 TEST_P(TDMLayer, LayerGetZpos)
587 TDM_UT_SKIP_FLAG(has_layers);
589 bool *check_table = (bool*)calloc(layer_count, output_count);
590 ASSERT_NE(check_table, NULL);
592 for (int l = 0; l < layer_count; l++) {
593 if (!tc_tdm_layer_is_avaiable(layers[l]))
595 unsigned int pipe = tc_tdm_layer_get_output_pipe(layers[l]);
596 int zpos = TDM_UT_INVALID_VALUE;
597 EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE);
598 EXPECT_TRUE(zpos != TDM_UT_INVALID_VALUE);
599 if (tc_tdm_layer_is_video_layer(layers[l]))
601 EXPECT_TRUE(zpos >= 0);
602 EXPECT_TRUE(pipe < (unsigned int)output_count);
603 EXPECT_TRUE(*(check_table + pipe * layer_count + zpos) == false);
604 *(check_table + pipe * layer_count + zpos) = true;
610 TEST_P(TDMLayer, LayerGetZposNullObject)
612 TDM_UT_SKIP_FLAG(has_layers);
614 int zpos = TDM_UT_INVALID_VALUE;
615 ASSERT_EQ(tdm_layer_get_zpos(NULL, &zpos), TDM_ERROR_INVALID_PARAMETER);
616 ASSERT_EQ(zpos, TDM_UT_INVALID_VALUE);
619 TEST_P(TDMLayer, LayerGetZposNullParam)
621 TDM_UT_SKIP_FLAG(has_layers);
623 ASSERT_EQ(tdm_layer_get_zpos(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
626 TEST_P(TDMLayer, DISABLED_LayerSetProperty)
630 TEST_P(TDMLayer, LayerSetPropertyNullObject)
632 tdm_value value = {.s32 = 0};
634 ASSERT_EQ(tdm_layer_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
637 TEST_P(TDMLayer, LayerGetProperty)
639 TDM_UT_SKIP_FLAG(has_layers);
641 for (int l = 0; l < layer_count; l++) {
642 if (!tc_tdm_layer_is_avaiable(layers[l]))
645 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
646 int count = TDM_UT_INVALID_VALUE;
647 ASSERT_EQ(tdm_layer_get_available_properties(layers[l], &props, &count), TDM_ERROR_NONE);
650 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
652 for (int i = 0; i < count; i++) {
653 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
654 ASSERT_EQ(tdm_layer_get_property(layers[l], props[i].id, &value), TDM_ERROR_NONE);
655 ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
661 TEST_P(TDMLayer, LayerGetPropertyNullObject)
663 TDM_UT_SKIP_FLAG(has_layers);
665 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
666 ASSERT_EQ(tdm_layer_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
667 ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
670 TEST_P(TDMLayer, LayerGetPropertyNullOther)
672 TDM_UT_SKIP_FLAG(has_layers);
674 ASSERT_EQ(tdm_layer_get_property(layers[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
677 TEST_P(TDMLayer, LayerSetInfo)
679 TDM_UT_SKIP_FLAG(has_layers);
681 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
683 for (int l = 0; l < layer_count; l++) {
684 if (!tc_tdm_layer_is_avaiable(layers[l]))
688 ASSERT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true);
689 ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE);
693 TEST_P(TDMLayer, LayerSetInfoNullObject)
695 TDM_UT_SKIP_FLAG(has_layers);
698 memset(&info, 0, sizeof info);
699 ASSERT_EQ(tdm_layer_set_info(NULL, &info), TDM_ERROR_INVALID_PARAMETER);
702 TEST_P(TDMLayer, LayerSetInfoNullOther)
704 TDM_UT_SKIP_FLAG(has_layers);
706 ASSERT_EQ(tdm_layer_set_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
709 TEST_P(TDMLayer, DISABLED_LayerGetInfo)
713 TEST_P(TDMLayer, LayerGetInfoNullObject)
715 TDM_UT_SKIP_FLAG(has_layers);
719 ASSERT_EQ(tdm_layer_get_info(NULL, &temp), TDM_ERROR_INVALID_PARAMETER);
722 TEST_P(TDMLayer, LayerGetInfoNullParam)
724 TDM_UT_SKIP_FLAG(has_layers);
726 ASSERT_EQ(tdm_layer_get_info(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
729 TEST_P(TDMLayer, LayerGetBufferFlags)
731 TDM_UT_SKIP_FLAG(has_layers);
733 for (int l = 0; l < layer_count; l++) {
734 if (!tc_tdm_layer_is_avaiable(layers[l]))
737 unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
738 ASSERT_EQ(tdm_layer_get_buffer_flags(layers[l], &flags), TDM_ERROR_NONE);
739 ASSERT_NE(flags, (unsigned int)TDM_UT_INVALID_VALUE);
743 TEST_P(TDMLayer, LayerGetBufferFlagsNullObject)
745 TDM_UT_SKIP_FLAG(has_layers);
747 unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE;
748 ASSERT_EQ(tdm_layer_get_buffer_flags(NULL, &flags), TDM_ERROR_INVALID_PARAMETER);
749 ASSERT_EQ(flags, (unsigned int)TDM_UT_INVALID_VALUE);
752 TEST_P(TDMLayer, LayerGetBufferFlagsNullOther)
754 TDM_UT_SKIP_FLAG(has_layers);
756 ASSERT_EQ(tdm_layer_get_buffer_flags(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
760 _tc_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence,
761 unsigned int tv_sec, unsigned int tv_usec,
764 bool *done = (bool*)user_data;
769 TEST_P(TDMLayer, LayerSetBuffer)
771 TDM_UT_SKIP_FLAG(has_layers);
775 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
777 for (int l = 0; l < layer_count; l++) {
778 if (!tc_tdm_layer_is_avaiable(layers[l]))
783 if (tc_tdm_layer_is_cursor_layer(layers[l]))
785 if (tc_tdm_layer_is_video_layer(layers[l]))
788 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
790 /* set buffer & commit for 100 times */
791 for (int t = 0; t < 10; t++) {
792 tbm_surface_h displaying_buffer = NULL;
793 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
794 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
795 while (displaying_buffer != buffers[next_buffer]) {
796 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
797 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
798 ASSERT_EQ(ret, TDM_ERROR_NONE);
801 if (next_buffer == 3)
809 TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit)
811 TDM_UT_SKIP_FLAG(has_layers);
815 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
817 for (int l = 0; l < layer_count; l++) {
818 if (!tc_tdm_layer_is_avaiable(layers[l]))
823 if (tc_tdm_layer_is_cursor_layer(layers[l]))
825 if (tc_tdm_layer_is_video_layer(layers[l]))
828 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
830 /* set buffer & commit for 10 times */
831 for (int t = 0; t < 10; t++) {
832 tbm_surface_h displaying_buffer = NULL;
833 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
834 if (next_buffer == 3)
836 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
837 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
838 while (displaying_buffer != buffers[next_buffer]) {
839 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
840 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
841 ASSERT_EQ(ret, TDM_ERROR_NONE);
844 if (next_buffer == 3)
852 TEST_P(TDMLayer, LayerSetBufferNullObject)
854 TDM_UT_SKIP_FLAG(has_layers);
856 tbm_surface_h buffer = (tbm_surface_h)TDM_UT_INVALID_VALUE;
857 ASSERT_EQ(tdm_layer_set_buffer(NULL, buffer), TDM_ERROR_INVALID_PARAMETER);
860 TEST_P(TDMLayer, LayerSetBufferNullOther)
862 TDM_UT_SKIP_FLAG(has_layers);
864 ASSERT_EQ(tdm_layer_set_buffer(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
867 TEST_P(TDMLayer, LayerUnsetBuffer)
869 TDM_UT_SKIP_FLAG(has_layers);
871 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
873 for (int l = 0; l < layer_count; l++) {
874 if (!tc_tdm_layer_is_avaiable(layers[l]))
877 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
881 TEST_P(TDMLayer, LayerUnsetBufferNullObject)
883 TDM_UT_SKIP_FLAG(has_layers);
885 ASSERT_EQ(tdm_layer_unset_buffer(NULL), TDM_ERROR_INVALID_PARAMETER);
888 TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit)
890 TDM_UT_SKIP_FLAG(has_layers);
892 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
894 for (int l = 0; l < layer_count; l++) {
895 if (!tc_tdm_layer_is_avaiable(layers[l]))
900 if (tc_tdm_layer_is_cursor_layer(layers[l]))
902 if (tc_tdm_layer_is_video_layer(layers[l]))
904 if (tc_tdm_layer_is_primary_layer(layers[l]))
907 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
909 /* set buffer & commit for 10 times */
910 for (int t = 0; t < 10; t++) {
911 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
912 if (next_buffer == 3)
914 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
915 if (next_buffer == 3)
919 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
925 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit)
927 TDM_UT_SKIP_FLAG(has_layers);
929 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
931 for (int l = 0; l < layer_count; l++) {
932 if (!tc_tdm_layer_is_avaiable(layers[l]))
937 if (tc_tdm_layer_is_cursor_layer(layers[l]))
939 if (tc_tdm_layer_is_video_layer(layers[l]))
941 if (tc_tdm_layer_is_primary_layer(layers[l]))
944 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
946 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
947 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
948 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
950 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
956 /* drmModePageFlip can't be done twice in a vblank */
957 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit)
959 TDM_UT_SKIP_FLAG(has_layers);
961 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
963 for (int l = 0; l < layer_count; l++) {
964 if (!tc_tdm_layer_is_avaiable(layers[l]))
969 if (tc_tdm_layer_is_cursor_layer(layers[l]))
971 if (tc_tdm_layer_is_video_layer(layers[l]))
973 if (tc_tdm_layer_is_primary_layer(layers[l]))
976 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
978 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
979 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
981 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
982 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
984 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
990 /* drmModePageFlip can't be done twice in a vblank */
991 TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer)
993 TDM_UT_SKIP_FLAG(has_layers);
995 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
997 for (int l = 0; l < layer_count; l++) {
998 if (!tc_tdm_layer_is_avaiable(layers[l]))
1001 int next_buffer = 0;
1003 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1005 if (tc_tdm_layer_is_video_layer(layers[l]))
1007 if (tc_tdm_layer_is_primary_layer(layers[l]))
1010 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1012 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1013 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1015 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1016 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1018 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
1020 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1026 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone)
1028 TDM_UT_SKIP_FLAG(has_layers);
1030 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1032 for (int l = 0; l < layer_count; l++) {
1033 if (!tc_tdm_layer_is_avaiable(layers[l]))
1036 int next_buffer = 0;
1039 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1041 if (tc_tdm_layer_is_video_layer(layers[l]))
1043 if (tc_tdm_layer_is_primary_layer(layers[l]))
1046 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1048 /* set buffer & commit for 10 times */
1049 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1050 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1053 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1055 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1058 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1064 TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit)
1066 TDM_UT_SKIP_FLAG(has_layers);
1068 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1070 for (int l = 0; l < layer_count; l++) {
1071 if (!tc_tdm_layer_is_avaiable(layers[l]))
1074 int next_buffer = 0;
1077 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1079 if (tc_tdm_layer_is_video_layer(layers[l]))
1081 if (tc_tdm_layer_is_primary_layer(layers[l]))
1084 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
1086 /* set buffer & commit for 10 times */
1087 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1088 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1091 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1093 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1096 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true);
1098 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE);
1100 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
1106 TEST_P(TDMLayer, LayerCommitDPMSOff)
1108 TDM_UT_SKIP_FLAG(has_layers);
1111 tdm_output *output = tdm_layer_get_output(layers[0], &ret);
1112 ASSERT_EQ(ret, TDM_ERROR_NONE);
1113 ASSERT_NE(output, NULL);
1115 if (!tc_tdm_output_is_connected(output))
1118 EXPECT_TRUE(tc_tdm_output_prepare(dpy, output, true) == true);
1120 EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE);
1122 EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF);
1124 EXPECT_TRUE(tc_tdm_output_unset(dpy, output) == true);
1127 TEST_P(TDMLayer, LayerCommitNullObject)
1129 TDM_UT_SKIP_FLAG(has_layers);
1131 ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1134 TEST_P(TDMLayer, LayerCommitNullOther)
1136 TDM_UT_SKIP_FLAG(has_layers);
1138 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1140 ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE);
1143 TEST_P(TDMLayer, LayerIsCommittingNullObject)
1145 TDM_UT_SKIP_FLAG(has_layers);
1147 unsigned int committing = (unsigned int)TDM_UT_INVALID_VALUE;
1148 ASSERT_EQ(tdm_layer_is_committing(NULL, &committing), TDM_ERROR_INVALID_PARAMETER);
1149 ASSERT_EQ(committing, (unsigned int)TDM_UT_INVALID_VALUE);
1152 TEST_P(TDMLayer, LayerIsCommittingNullOther)
1154 TDM_UT_SKIP_FLAG(has_layers);
1156 ASSERT_EQ(tdm_layer_is_committing(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1159 TEST_P(TDMLayer, LayerRemoveCommitHandler)
1161 TDM_UT_SKIP_FLAG(has_layers);
1163 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1165 for (int l = 0; l < layer_count; l++) {
1166 if (!tc_tdm_layer_is_avaiable(layers[l]))
1170 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1171 ASSERT_EQ(ret, TDM_ERROR_NONE);
1172 ASSERT_NE(output, NULL);
1174 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1176 if (tc_tdm_layer_is_video_layer(layers[l]))
1178 if (tc_tdm_layer_is_primary_layer(layers[l]))
1181 ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
1183 ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
1185 for (int t = 0; t < 10; t++) {
1186 bool done1 = false, done2 = false, done3 = false;
1187 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1188 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1189 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1190 ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1191 while (!done1 || done2 || !done3) {
1192 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1200 TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData)
1202 TDM_UT_SKIP_FLAG(has_layers);
1204 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1206 for (int l = 0; l < layer_count; l++) {
1207 if (!tc_tdm_layer_is_avaiable(layers[l]))
1211 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1212 ASSERT_EQ(ret, TDM_ERROR_NONE);
1213 ASSERT_NE(output, NULL);
1215 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1217 if (tc_tdm_layer_is_video_layer(layers[l]))
1219 if (tc_tdm_layer_is_primary_layer(layers[l]))
1222 for (int t = 0; t < 10; t++) {
1223 bool done1 = false, done2 = false, done3 = false;
1224 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE);
1225 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE);
1226 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE);
1227 ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE);
1228 while (!done1 || !done2 || !done3) {
1229 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1235 _tc_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence,
1236 unsigned int tv_sec, unsigned int tv_usec,
1239 bool *done = (bool*)user_data;
1242 ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE);
1245 TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler)
1247 TDM_UT_SKIP_FLAG(has_layers);
1249 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1251 for (int l = 0; l < layer_count; l++) {
1252 if (!tc_tdm_layer_is_avaiable(layers[l]))
1256 tdm_output *output = tdm_layer_get_output(layers[l], &ret);
1257 ASSERT_EQ(ret, TDM_ERROR_NONE);
1258 ASSERT_NE(output, NULL);
1260 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1262 if (tc_tdm_layer_is_video_layer(layers[l]))
1264 if (tc_tdm_layer_is_primary_layer(layers[l]))
1267 for (int t = 0; t < 10; t++) {
1268 bool done1 = false, done2 = false, done3 = false;
1269 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE);
1270 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE);
1271 ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE);
1272 while (!done1 || !done2 || !done3) {
1273 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1279 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject)
1281 TDM_UT_SKIP_FLAG(has_layers);
1283 ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1286 TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther)
1288 TDM_UT_SKIP_FLAG(has_layers);
1290 ASSERT_EQ(tdm_layer_remove_commit_handler(layers[0], NULL, NULL), TDM_ERROR_NONE);
1293 TEST_P(TDMLayer, LayerGetDisplayingBufferNullObject)
1295 TDM_UT_SKIP_FLAG(has_layers);
1297 tbm_surface_h displaying_buffer;
1299 displaying_buffer = tdm_layer_get_displaying_buffer(NULL, &ret);
1300 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1301 ASSERT_EQ(displaying_buffer, NULL);
1304 TEST_P(TDMLayer, LayerGetDisplayingBufferNullOther)
1306 TDM_UT_SKIP_FLAG(has_layers);
1308 tbm_surface_h displaying_buffer;
1309 displaying_buffer = tdm_layer_get_displaying_buffer(layers[0], NULL);
1310 ASSERT_EQ(displaying_buffer, NULL);
1313 TEST_P(TDMLayer, LayerIsUsableNullObject)
1315 TDM_UT_SKIP_FLAG(has_layers);
1317 unsigned int usable = (unsigned int)TDM_UT_INVALID_VALUE;
1318 ASSERT_EQ(tdm_layer_is_usable(NULL, &usable), TDM_ERROR_INVALID_PARAMETER);
1319 ASSERT_EQ(usable, (unsigned int)TDM_UT_INVALID_VALUE);
1322 TEST_P(TDMLayer, LayerSetBufferQueue)
1324 TDM_UT_SKIP_FLAG(has_layers);
1328 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1330 for (int l = 0; l < layer_count; l++) {
1331 if (!tc_tdm_layer_is_avaiable(layers[l]))
1334 tbm_surface_h buffer;
1335 tbm_surface_h displaying_buffer;
1337 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1339 if (tc_tdm_layer_is_video_layer(layers[l]))
1341 if (tc_tdm_layer_is_primary_layer(layers[l]))
1344 ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true);
1345 ASSERT_NE(buffer_queue, NULL);
1347 ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true);
1349 ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE);
1351 for (int t = 0; t < 10; t++) {
1352 ASSERT_EQ(tbm_surface_queue_dequeue(buffer_queue, &buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1353 ASSERT_NE(buffer, NULL);
1354 tdm_test_buffer_fill(buffer, PATTERN_SMPTE);
1355 ASSERT_EQ(tbm_surface_queue_enqueue(buffer_queue, buffer), TBM_SURFACE_QUEUE_ERROR_NONE);
1357 displaying_buffer = NULL;
1358 while (displaying_buffer != buffer) {
1359 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1360 displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret);
1361 ASSERT_EQ(ret, TDM_ERROR_NONE);
1365 ASSERT_EQ(tdm_layer_unset_buffer_queue(layers[l]), TDM_ERROR_NONE);
1371 TEST_P(TDMLayer, LayerSetBufferQueueTwice)
1373 TDM_UT_SKIP_FLAG(has_layers);
1375 tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true);
1377 for (int l = 0; l < layer_count; l++) {
1378 tbm_surface_queue_h buffer_queue1 = NULL;
1379 tbm_surface_queue_h buffer_queue2 = NULL;
1381 if (!tc_tdm_layer_is_avaiable(layers[l]))
1383 if (tc_tdm_layer_is_cursor_layer(layers[l]))
1385 if (tc_tdm_layer_is_video_layer(layers[l]))
1388 EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true);
1389 EXPECT_TRUE(buffer_queue1 != NULL);
1390 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue1) == TDM_ERROR_NONE);
1392 EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true);
1393 EXPECT_TRUE(buffer_queue2 != NULL);
1394 EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue2) == TDM_ERROR_NONE);
1397 tbm_surface_queue_destroy(buffer_queue1);
1399 tbm_surface_queue_destroy(buffer_queue2);
1403 TEST_P(TDMLayer, LayerSetBufferQueueNullObject)
1405 TDM_UT_SKIP_FLAG(has_layers);
1407 tbm_surface_queue_h buffer_queue = (tbm_surface_queue_h)TDM_UT_INVALID_VALUE;
1409 ASSERT_EQ(tdm_layer_set_buffer_queue(NULL, buffer_queue), TDM_ERROR_INVALID_PARAMETER);
1412 TEST_P(TDMLayer, LayerSetBufferQueueNullOther)
1414 TDM_UT_SKIP_FLAG(has_layers);
1416 ASSERT_EQ(tdm_layer_set_buffer_queue(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1419 TEST_P(TDMLayer, LayerUnsetBufferQueueNullObject)
1421 TDM_UT_SKIP_FLAG(has_layers);
1423 ASSERT_EQ(tdm_layer_unset_buffer_queue(NULL), TDM_ERROR_INVALID_PARAMETER);
1426 TEST_P(TDMLayer, LayerIsUsableNullOther)
1428 TDM_UT_SKIP_FLAG(has_layers);
1430 ASSERT_EQ(tdm_layer_is_usable(layers[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1433 TEST_P(TDMLayer, LayerSetVideoPos)
1435 TDM_UT_SKIP_FLAG(has_layers);
1437 for (int l = 0; l < layer_count; ++l) {
1438 if (!tc_tdm_layer_is_avaiable(layers[l]))
1441 if (!tc_tdm_layer_is_video_layer(layers[l]))
1443 ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE);
1447 TEST_P(TDMLayer, LayerSetVideoPosNullObject)
1449 TDM_UT_SKIP_FLAG(has_layers);
1451 ASSERT_EQ(tdm_layer_set_video_pos(NULL, -1), TDM_ERROR_INVALID_PARAMETER);
1454 TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer)
1456 TDM_UT_SKIP_FLAG(has_layers);
1458 for (int l = 0; l < layer_count; ++l) {
1459 if (!tc_tdm_layer_is_avaiable(layers[l]))
1462 if (tc_tdm_layer_is_video_layer(layers[l]))
1465 ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST);
1469 TEST_P(TDMLayer, LayerCreateCapture)
1471 TDM_UT_SKIP_FLAG(has_layers);
1473 for (int l = 0; l < layer_count; ++l) {
1475 tdm_capture *capture;
1477 if (!tc_tdm_layer_is_avaiable(layers[l]))
1480 capture = tdm_layer_create_capture(layers[l], &ret);
1481 if (ret == TDM_ERROR_NONE)
1482 ASSERT_NE(capture, NULL);
1486 TEST_P(TDMLayer, LayerCreateCaptureNullObject)
1488 TDM_UT_SKIP_FLAG(has_layers);
1491 tdm_capture *capture = tdm_layer_create_capture(NULL, &ret);
1492 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
1493 ASSERT_EQ(capture, NULL);
1496 #ifdef TDM_UT_TEST_WITH_PARAMS
1497 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1499 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1501 INSTANTIATE_TEST_CASE_P(TDMLayerParams,
1503 Values(TDM_DEFAULT_MODULE));