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 **************************************************************************/
33 #define TDM_UT_BACKEND_TEST_CNT 20
35 TDMBackendBasic::TDMBackendBasic()
43 for (int b = 0; b < 3; b++)
47 void TDMBackendBasic::SetUp(void)
51 TDMBackendEnv::SetUp();
53 dpy = tdm_display_init(&ret);
54 ASSERT_EQ(ret, TDM_ERROR_NONE);
57 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
58 ASSERT_GE(output_count, 0);
60 if (output_count > 0) {
61 outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
62 ASSERT_NE(outputs, NULL);
64 for (int o = 0; o < output_count; o++) {
66 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
67 ASSERT_EQ(ret, TDM_ERROR_NONE);
68 ASSERT_NE(output, NULL);
73 for (int o = 0; o < output_count; o++) {
74 int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
77 if (ut_tdm_output_is_hwc_enable(outputs[o]))
80 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
84 layers = (tdm_layer**)realloc((void*)layers, sizeof(tdm_layer*) * layer_count);
85 ASSERT_NE(layers, NULL);
87 for (int l = 0; l < count; l++) {
88 tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
89 ASSERT_NE(layer, NULL);
90 ASSERT_EQ(ret, TDM_ERROR_NONE);
91 layers[old_layer_count + l] = layer;
96 void TDMBackendBasic::TearDown(void)
98 tdm_display_deinit(dpy);
111 ASSERT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
113 TDMBackendEnv::TearDown();
116 void TDMBackendBasic::DestroyBuffers(void)
118 for (int b = 0; b < 3; b++) {
120 tbm_surface_destroy(buffers[b]);
125 TEST_P(TDMBackendBasic, VerifyOutputObject)
128 int output_count = 0;
130 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
131 TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs().");
133 for (int o = 0; o < output_count; o++) {
134 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
135 ASSERT_EQ(ret, TDM_ERROR_NONE);
136 TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o);
140 TEST_P(TDMBackendBasic, VerifyLayerObject)
143 int output_count = 0;
145 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
147 for (int o = 0; o < output_count; o++) {
148 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
149 ASSERT_EQ(ret, TDM_ERROR_NONE);
152 ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
153 TDM_UT_ASSERT_TRUE(layer_count > 0,
154 "layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().",
157 for (int l = 0; l < layer_count; l++) {
158 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
159 TDM_UT_ASSERT_TRUE(layer != NULL, "no layer. (output: %d, layer: %d). Check output_get_layers().", o, l);
164 TEST_P(TDMBackendBasic, VerifyOutputGetProperty)
167 int output_count = 0;
169 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
171 for (int o = 0; o < output_count; o++) {
172 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
173 ASSERT_EQ(ret, TDM_ERROR_NONE);
175 const tdm_prop *props = NULL;
177 ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
180 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o);
182 for (int p = 0; p < prop_count; p++) {
184 value.s32 = TDM_UT_INVALID_VALUE;
185 ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
186 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
187 "Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().",
193 TEST_P(TDMBackendBasic, VerifyLayerGetProperty)
196 int output_count = 0;
198 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
200 for (int o = 0; o < output_count; o++) {
201 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
202 ASSERT_EQ(ret, TDM_ERROR_NONE);
205 ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
207 for (int l = 0; l < layer_count; l++) {
208 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
209 ASSERT_EQ(ret, TDM_ERROR_NONE);
211 const tdm_prop *props = NULL;
213 ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
216 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l);
218 for (int p = 0; p < prop_count; p++) {
220 value.s32 = TDM_UT_INVALID_VALUE;
221 ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
222 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
223 "Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().",
230 TEST_P(TDMBackendBasic, VerifyOutputSetMode)
232 for (int o = 0; o < output_count; o++) {
233 const tdm_output_mode *got_mode = NULL;
234 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
235 const tdm_output_mode *set_mode = NULL;
236 const tdm_output_mode *best = NULL;
237 int count = TDM_UT_INVALID_VALUE;
239 if (!ut_tdm_output_is_connected(outputs[o]))
242 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
243 TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
244 TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
246 for (int i = 0; i < count; i++) {
249 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
250 set_mode = &modes[i];
252 if (!set_mode && best)
254 ASSERT_NE(set_mode, NULL);
256 ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
257 ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
258 TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()");
262 TEST_P(TDMBackendBasic, VerifyOutputSetDpms)
264 for (int o = 0; o < output_count; o++) {
265 const tdm_output_mode *got_mode = NULL;
266 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
267 const tdm_output_mode *set_mode = NULL;
268 const tdm_output_mode *best = NULL;
269 int count = TDM_UT_INVALID_VALUE;
270 tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF;
271 tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON;
273 if (!ut_tdm_output_is_connected(outputs[o]))
276 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
278 ASSERT_NE(modes, NULL);
280 for (int i = 0; i < count; i++) {
283 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
284 set_mode = &modes[i];
286 if (!set_mode && best)
289 ASSERT_NE(set_mode, NULL);
290 ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
291 ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
292 ASSERT_EQ(set_mode, got_mode);
294 ASSERT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
295 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
296 TDM_UT_ASSERT_TRUE(set_dpms == got_dpms, "The dpms value which is set and got are different. Check output_set_dpms(), output_get_dpms()");
300 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame)
302 for (int o = 0; o < output_count; o++) {
305 if (!ut_tdm_output_is_connected(outputs[o]))
308 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
309 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
311 layer = ut_tdm_output_get_primary_layer(outputs[o]);
312 ASSERT_NE(layer, NULL);
315 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
316 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
319 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
321 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
323 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
324 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
329 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames)
331 for (int o = 0; o < output_count; o++) {
335 if (!ut_tdm_output_is_connected(outputs[o]))
338 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
339 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
341 layer = ut_tdm_output_get_primary_layer(outputs[o]);
342 ASSERT_NE(layer, NULL);
345 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
347 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
348 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
349 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
350 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
351 usleep(40000); /* 40 ms */
353 if (next_buffer == 3)
359 TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o);
361 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
362 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
367 _ut_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence,
368 unsigned int tv_sec, unsigned int tv_usec,
371 bool *done = (bool*)user_data;
376 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler)
378 for (int o = 0; o < output_count; o++) {
381 if (!ut_tdm_output_is_connected(outputs[o]))
384 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
385 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
387 layer = ut_tdm_output_get_primary_layer(outputs[o]);
388 ASSERT_NE(layer, NULL);
391 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
392 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
396 TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE,
397 "Check output_commit(), output_set_commit_handler()");
399 TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
400 "Check display_get_fd(), display_handle_events()");
402 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
404 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
405 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
409 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame)
411 for (int o = 0; o < output_count; o++) {
414 if (!ut_tdm_output_is_connected(outputs[o]))
417 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
418 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
420 layer = ut_tdm_output_get_primary_layer(outputs[o]);
421 ASSERT_NE(layer, NULL);
423 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
424 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
427 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
428 usleep(40000); /* 40 ms */
431 for (int l = 0; l < layer_count; l++) {
434 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
436 ASSERT_EQ(ret, TDM_ERROR_NONE);
437 if (ut_tdm_layer_is_primary_layer(layers[l]))
439 if (ut_tdm_layer_is_cursor_layer(layers[l]))
441 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
442 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true);
446 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
448 TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o);
450 for (int l = 0; l < layer_count; l++)
451 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
452 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
456 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames)
458 for (int o = 0; o < output_count; o++) {
461 if (!ut_tdm_output_is_connected(outputs[o]))
464 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
465 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
467 layer = ut_tdm_output_get_primary_layer(outputs[o]);
468 ASSERT_NE(layer, NULL);
470 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
471 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
474 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
475 usleep(40000); /* 40 ms */
477 for (int l = 0; l < layer_count; l++) {
481 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
483 ASSERT_EQ(ret, TDM_ERROR_NONE);
484 if (ut_tdm_layer_is_primary_layer(layers[l]))
486 if (ut_tdm_layer_is_cursor_layer(layers[l]))
490 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
492 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
493 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
494 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
495 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
496 usleep(40000); /* 40 ms */
498 if (next_buffer == 3)
504 TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l);
506 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
507 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
508 usleep(40000); /* 40 ms */
513 TEST_P(TDMBackendBasic, DISABLED_VerifyCursorLayer)
518 _ut_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence,
519 unsigned int tv_sec, unsigned int tv_usec,
522 bool *done = (bool*)user_data;
527 TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
529 for (int o = 0; o < output_count; o++) {
532 if (!ut_tdm_output_is_connected(outputs[o]))
535 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
536 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
538 layer = ut_tdm_output_get_primary_layer(outputs[o]);
539 ASSERT_NE(layer, NULL);
541 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
542 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
545 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
548 for (int t = 1; t < 10; t++) {
549 double start, end, interval;
552 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
555 start = tdm_helper_get_time();
556 TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE,
557 "Check output_wait_vblank(), output_set_vblank_handler()");
559 TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
560 "Check display_get_fd(), display_handle_events()");
561 end = tdm_helper_get_time();
563 /* "+ interval" consider the delay of socket communication between kernel and platform */
564 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
565 "The vblank event should happen after %d vsync intervals(%d ms).\n"
566 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
567 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
568 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
569 "The vblank event should happen after %d vsync intervals(%d ms).\n"
570 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
571 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
577 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
579 for (int o = 0; o < output_count; o++) {
582 if (!ut_tdm_output_is_connected(outputs[o]))
585 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
586 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
588 layer = ut_tdm_output_get_primary_layer(outputs[o]);
589 ASSERT_NE(layer, NULL);
591 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
592 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
595 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
598 for (int t = 1; t < 10; t++) {
599 double start, end, interval;
602 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
605 start = tdm_helper_get_time();
606 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
608 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
609 end = tdm_helper_get_time();
611 /* "+ interval" consider the delay of socket communication between kernel and platform */
612 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
613 "The vblank event should happen after %d vsync intervals(%d ms).\n"
614 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
615 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
616 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
617 "The vblank event should happen after %d vsync intervals(%d ms).\n"
618 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
619 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
624 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
626 for (int o = 0; o < output_count; o++) {
629 if (!ut_tdm_output_is_connected(outputs[o]))
632 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
633 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
635 layer = ut_tdm_output_get_primary_layer(outputs[o]);
636 ASSERT_NE(layer, NULL);
638 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
639 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
642 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
645 for (int t = 1; t < 10; t++) {
646 double start, end, interval;
647 bool done1, done2, done3;
649 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
651 done1 = done2 = done3 = false;
652 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
653 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
654 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
655 start = tdm_helper_get_time();
656 while (!done1 || !done2 || !done3)
657 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
658 end = tdm_helper_get_time();
660 /* "+ interval" consider the delay of socket communication between kernel and platform */
661 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
662 "The vblank event should happen after %d vsync intervals(%d ms).\n"
663 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
664 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
665 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
666 "The vblank event should happen after %d vsync intervals(%d ms).\n"
667 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
668 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
673 TEST_P(TDMBackendBasic, VerifyPPObject)
678 if (!ut_tdm_display_has_pp_capability(dpy)) {
679 TDM_UT_INFO("PP not supported");
683 pp = tdm_display_create_pp(dpy, &ret);
684 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "can't create a PP object. Check display_create_pp()");
685 TDM_UT_ASSERT_TRUE(pp != NULL, "can't create a PP object. Check display_create_pp()");
690 TEST_P(TDMBackendBasic, VerifyPPCapabilities)
692 tdm_pp_capability capabilities = (tdm_pp_capability)0;
694 if (!ut_tdm_display_has_pp_capability(dpy)) {
695 TDM_UT_INFO("PP not supported");
699 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE,
700 "Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
701 TDM_UT_ASSERT_TRUE(capabilities != (tdm_pp_capability)0,
702 "PP has no capability. Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
705 TEST_P(TDMBackendBasic, VerifyPPAvaiableSize)
707 if (!ut_tdm_display_has_pp_capability(dpy)) {
708 TDM_UT_INFO("PP not supported");
716 int preferred_align = 0;
717 ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
722 ASSERT_NE(preferred_align, 0);
725 TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
727 if (!ut_tdm_display_has_pp_capability(dpy)) {
728 TDM_UT_INFO("PP not supported");
732 const tbm_format *formats = NULL;
733 int format_count = 0;
734 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
735 "Check display_get_pp_capability(), tdm_caps_pp");
736 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_pp_capability(), tdm_caps_pp.");
737 TDM_UT_ASSERT_TRUE(format_count > 0, "Format count should be greater than 0. Check display_get_pp_capability(), tdm_caps_pp.");
740 TEST_P(TDMBackendBasic, VerifyCaptureObject)
742 if (!ut_tdm_display_has_capture_capability(dpy)) {
743 TDM_UT_INFO("Capture not supported.");
747 for (int o = 0; o < output_count; o++) {
748 tdm_capture *capture;
751 unsigned int has_capability = 0;
752 ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
753 if (!has_capability) {
754 TDM_UT_INFO("Capture not supported. (output: %d)", o);
758 if (!ut_tdm_output_is_connected(outputs[o]))
761 capture = tdm_output_create_capture(outputs[o], &ret);
762 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "Can't create a capture object. Check output_create_capture().");
763 TDM_UT_ASSERT_TRUE(capture != NULL, "Can't create a capture object. Check output_create_capture().");
765 tdm_capture_destroy(capture);
769 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize)
771 if (!ut_tdm_display_has_capture_capability(dpy)) {
772 TDM_UT_INFO("Capture not supported.");
780 int preferred_align = 0;
781 ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
786 ASSERT_NE(preferred_align, 0);
789 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
791 if (!ut_tdm_display_has_capture_capability(dpy)) {
792 TDM_UT_INFO("Capture not supported.");
796 const tbm_format *formats = NULL;
797 int format_count = 0;
798 TDM_UT_ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
799 "Check display_get_capture_capability(), tdm_caps_capture.");
800 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_capture_capability(), tdm_caps_capture.");
801 TDM_UT_ASSERT_TRUE(format_count > 0, "The format count should be greater than 0. Check display_get_capture_capability(), tdm_caps_capture.");
804 #ifdef TDM_UT_TEST_WITH_PARAMS
805 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
807 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
809 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
811 Values(TDM_DEFAULT_MODULE));
814 TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat)
816 for (int o = 0; o < output_count; o++) {
821 const tbm_format *formats;
822 int format_count = 0;
823 const tdm_output_mode *mode = NULL;
824 unsigned int flags = 0;
826 if (!ut_tdm_output_is_connected(outputs[o]))
829 layer = ut_tdm_output_get_primary_layer(outputs[o]);
830 ASSERT_NE(layer, NULL);
832 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
833 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
835 for (int f = 0; f < format_count; f++) {
836 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
837 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
838 ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
839 ASSERT_NE(mode, NULL);
842 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
843 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
845 /* set buffer & commit for 60 times */
846 for (int t = 0; t < 60; t++) {
847 tbm_surface_h displaying_buffer;
848 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
850 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
852 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
853 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
854 ASSERT_EQ(ret, TDM_ERROR_NONE);
855 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
857 if (next_buffer == 3)
863 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a primary layer? (output: %d)", FOURCC_STR(formats[f]), o);
868 TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
870 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
872 for (int l = 0; l < layer_count; l++) {
878 const tbm_format *formats;
879 int format_count = 0;
880 const tdm_output_mode *mode = NULL;
881 unsigned int flags = 0;
882 unsigned int pipe = 0;
886 output = tdm_layer_get_output(layer, &ret);
887 ASSERT_EQ(ret, TDM_ERROR_NONE);
889 if (!ut_tdm_output_is_connected(output))
891 if (ut_tdm_layer_is_primary_layer(layer))
893 if (ut_tdm_layer_is_cursor_layer(layer))
896 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
898 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
900 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
901 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
902 ASSERT_NE(mode, NULL);
904 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
906 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
908 for (int f = 0; f < format_count; f++) {
910 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
911 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
913 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
914 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
915 tbm_surface_h displaying_buffer;
916 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
918 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
920 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
921 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
922 ASSERT_EQ(ret, TDM_ERROR_NONE);
923 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
925 if (next_buffer == 3)
929 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a layer? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, l);
934 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
938 TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
940 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
942 for (int l = 0; l < layer_count; l++) {
948 const tbm_format *formats;
949 int format_count = 0;
950 const tdm_output_mode *mode = NULL;
951 unsigned int flags = 0;
952 unsigned int pipe = 0;
956 output = tdm_layer_get_output(layer, &ret);
957 ASSERT_EQ(ret, TDM_ERROR_NONE);
959 if (!ut_tdm_output_is_connected(output))
961 if (ut_tdm_layer_is_primary_layer(layer))
963 if (ut_tdm_layer_is_cursor_layer(layer))
966 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
968 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
970 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
971 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
972 ASSERT_NE(mode, NULL);
974 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
976 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
978 for (int f = 0; f < format_count; f++) {
979 int diffw = mode->hdisplay / (format_count + 2);
980 int diffh = mode->vdisplay / (format_count + 2);
981 int w = mode->hdisplay - diffw * (f + 1);
982 int h = mode->vdisplay - diffh * (f + 1);
984 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
985 ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
987 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
988 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
989 tbm_surface_h displaying_buffer;
990 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
992 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
994 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
995 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
996 ASSERT_EQ(ret, TDM_ERROR_NONE);
997 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
999 if (next_buffer == 3)
1005 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' small size(%dx%d) frames to a layer? (output: %d, layer: %d)",
1006 FOURCC_STR(formats[f]), w, h, pipe, l);
1009 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1013 TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
1015 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1017 for (int l = 0; l < layer_count; l++) {
1021 int next_buffer = 0;
1023 const tbm_format *formats;
1024 int format_count = 0;
1025 const tdm_output_mode *mode = NULL;
1026 unsigned int flags = 0;
1027 unsigned int pipe = 0;
1031 output = tdm_layer_get_output(layer, &ret);
1032 ASSERT_EQ(ret, TDM_ERROR_NONE);
1034 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1036 if (!ut_tdm_output_is_connected(output))
1038 if (ut_tdm_layer_is_primary_layer(layer))
1040 if (ut_tdm_layer_is_cursor_layer(layer))
1042 if (!ut_tdm_layer_support_scale(layer)) {
1043 TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l);
1047 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1048 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1049 ASSERT_NE(mode, NULL);
1051 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1053 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1055 for (int f = 0; f < format_count; f++) {
1057 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
1058 ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1060 tdm_info_layer info;
1061 memset(&info, 0, sizeof info);
1062 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1063 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1064 info.src_config.pos.x = 0;
1065 info.src_config.pos.y = 0;
1066 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1067 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1068 info.src_config.format = formats[f];
1071 info.dst_pos.w = mode->hdisplay;
1072 info.dst_pos.h = mode->vdisplay;
1073 info.transform = TDM_TRANSFORM_NORMAL;
1074 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1076 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1077 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1078 tbm_surface_h displaying_buffer;
1079 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1081 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1083 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1084 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1085 ASSERT_EQ(ret, TDM_ERROR_NONE);
1086 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1088 if (next_buffer == 3)
1094 TDM_UT_ASK_YNR("* Successed to scale '%c%c%c%c' small size(%dx%d) frames to fullsreen? (output: %d, layer: %d)",
1095 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1098 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1102 TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
1104 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1106 for (int l = 0; l < layer_count; l++) {
1110 int next_buffer = 0;
1112 const tbm_format *formats;
1113 int format_count = 0;
1114 const tdm_output_mode *mode = NULL;
1115 unsigned int flags = 0;
1116 unsigned int pipe = 0;
1120 output = tdm_layer_get_output(layer, &ret);
1121 ASSERT_EQ(ret, TDM_ERROR_NONE);
1123 if (!ut_tdm_output_is_connected(output))
1125 if (ut_tdm_layer_is_primary_layer(layer))
1127 if (ut_tdm_layer_is_cursor_layer(layer))
1130 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1132 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1134 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1135 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1136 ASSERT_NE(mode, NULL);
1138 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1140 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1142 for (int f = 0; f < format_count; f++) {
1144 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1145 ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1147 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1148 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1149 tbm_surface_h displaying_buffer;
1151 tdm_info_layer info;
1152 memset(&info, 0, sizeof info);
1153 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1154 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1155 info.src_config.pos.x = 0;
1156 info.src_config.pos.y = 0;
1157 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1158 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1159 info.src_config.format = formats[f];
1160 info.dst_pos.x = ((mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1161 info.dst_pos.y = ((mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1162 info.dst_pos.w = TDM_UT_BUFFER_SIZE;
1163 info.dst_pos.h = TDM_UT_BUFFER_SIZE;
1164 info.transform = TDM_TRANSFORM_NORMAL;
1165 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1167 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1169 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1171 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1172 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1173 ASSERT_EQ(ret, TDM_ERROR_NONE);
1174 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1176 if (next_buffer == 3)
1182 TDM_UT_ASK_YNR("* Successed to move '%c%c%c%c' small size(%dx%d) frames on screen? (output: %d, layer: %d)",
1183 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1186 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1190 TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
1192 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1194 for (int l = 0; l < layer_count; l++) {
1198 int next_buffer = 0;
1200 const tbm_format *formats;
1201 int format_count = 0;
1202 const tdm_output_mode *mode = NULL;
1203 unsigned int flags = 0;
1204 unsigned int pipe = 0;
1208 output = tdm_layer_get_output(layer, &ret);
1209 ASSERT_EQ(ret, TDM_ERROR_NONE);
1211 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1213 if (!ut_tdm_output_is_connected(output))
1215 if (ut_tdm_layer_is_primary_layer(layer))
1217 if (ut_tdm_layer_is_cursor_layer(layer))
1219 if (ut_tdm_layer_support_no_crop(layer)) {
1220 TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l);
1224 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1226 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1227 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1228 ASSERT_NE(mode, NULL);
1230 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1232 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1234 for (int f = 0; f < format_count; f++) {
1236 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1237 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1239 tdm_info_layer info;
1240 memset(&info, 0, sizeof info);
1241 info.src_config.size.h = mode->hdisplay;
1242 info.src_config.size.v = mode->vdisplay;
1243 info.src_config.pos.x = mode->hdisplay / 2;
1244 info.src_config.pos.y = mode->vdisplay / 2;
1245 info.src_config.pos.w = info.src_config.size.h / 2;
1246 info.src_config.pos.h = info.src_config.size.v / 2;
1247 info.src_config.format = formats[f];
1248 info.dst_pos.x = info.src_config.pos.x;
1249 info.dst_pos.y = info.src_config.pos.y;
1250 info.dst_pos.w = info.src_config.pos.w;
1251 info.dst_pos.h = info.src_config.pos.h;
1252 info.transform = TDM_TRANSFORM_NORMAL;
1253 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1255 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1256 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1257 tbm_surface_h displaying_buffer;
1258 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1260 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1262 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1263 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1264 ASSERT_EQ(ret, TDM_ERROR_NONE);
1265 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1267 if (next_buffer == 3)
1273 TDM_UT_ASK_YNR("* Successed to crop '%c%c%c%c' frames and display it? (output: %d, layer: %d)",
1274 FOURCC_STR(formats[f]), pipe, l);
1277 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1281 /* should be debugged int emulator kernel */
1282 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
1284 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1286 for (int o = 0; o < output_count; o++) {
1287 if (!ut_tdm_output_is_connected(outputs[o]))
1290 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1294 /* should be debugged int emulator kernel */
1295 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
1297 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1299 for (int o = 0; o < output_count; o++) {
1300 if (!ut_tdm_output_is_connected(outputs[o]))
1303 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1304 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1308 /* should be debugged int emulator kernel */
1309 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet)
1311 for (int o = 0; o < output_count; o++) {
1312 if (!ut_tdm_output_is_connected(outputs[o]))
1315 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
1316 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1320 /* should be debugged int emulator kernel */
1321 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet)
1323 for (int o = 0; o < output_count; o++) {
1324 if (!ut_tdm_output_is_connected(outputs[o]))
1327 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
1328 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1332 /* should be debugged int emulator kernel */
1333 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit)
1335 for (int o = 0; o < output_count; o++) {
1336 if (!ut_tdm_output_is_connected(outputs[o]))
1339 ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
1341 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1342 ASSERT_NE(layer, NULL);
1344 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1346 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1350 /* should be debugged int emulator kernel */
1351 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit)
1353 for (int o = 0; o < output_count; o++) {
1354 if (!ut_tdm_output_is_connected(outputs[o]))
1357 ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
1359 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1360 ASSERT_NE(layer, NULL);
1362 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1363 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1365 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1369 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync)
1373 TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
1375 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1377 for (int o = 0; o < output_count; o++) {
1378 if (!ut_tdm_output_is_connected(outputs[o]))
1381 tbm_surface_h displaying_buffer;
1383 tdm_info_layer info, temp;
1384 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1385 ASSERT_NE(layer, NULL);
1387 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1388 ASSERT_NE(displaying_buffer, NULL);
1389 ASSERT_EQ(ret, TDM_ERROR_NONE);
1390 ASSERT_EQ(ut_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
1391 ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
1392 ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0);
1396 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputWaitVblankBeforeDpmsOff) /* TODO */
1400 TEST_P(TDMBackendDisplay, DISABLED_VerifyLayerSetVideoPos)
1404 #ifdef TDM_UT_TEST_WITH_PARAMS
1405 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1407 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1409 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1411 Values(TDM_DEFAULT_MODULE));