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(layers, layer_count * sizeof(tdm_layer*));
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]);
126 ut_tdm_backend_getchar(void)
131 if (ch == '\n' || ch == '\r')
136 while (c != '\n' && c != EOF)
142 TEST_P(TDMBackendBasic, VerifyOutputObject)
145 int output_count = 0;
147 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
148 TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs().");
150 for (int o = 0; o < output_count; o++) {
151 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
152 ASSERT_EQ(ret, TDM_ERROR_NONE);
153 TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o);
157 TEST_P(TDMBackendBasic, VerifyLayerObject)
160 int output_count = 0;
162 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
164 for (int o = 0; o < output_count; o++) {
165 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
166 ASSERT_EQ(ret, TDM_ERROR_NONE);
169 ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
170 TDM_UT_ASSERT_TRUE(layer_count > 0,
171 "layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().",
174 for (int l = 0; l < layer_count; l++) {
175 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
176 TDM_UT_ASSERT_TRUE(layer != NULL, "no layer. (output: %d, layer: %d). Check output_get_layers().", o, l);
181 TEST_P(TDMBackendBasic, VerifyOutputGetProperty)
184 int output_count = 0;
186 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
188 for (int o = 0; o < output_count; o++) {
189 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
190 ASSERT_EQ(ret, TDM_ERROR_NONE);
192 const tdm_prop *props = NULL;
194 ASSERT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
197 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o);
199 for (int p = 0; p < prop_count; p++) {
201 value.s32 = TDM_UT_INVALID_VALUE;
202 ASSERT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
203 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
204 "Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().",
210 TEST_P(TDMBackendBasic, VerifyLayerGetProperty)
213 int output_count = 0;
215 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
217 for (int o = 0; o < output_count; o++) {
218 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
219 ASSERT_EQ(ret, TDM_ERROR_NONE);
222 ASSERT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
224 for (int l = 0; l < layer_count; l++) {
225 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
226 ASSERT_EQ(ret, TDM_ERROR_NONE);
228 const tdm_prop *props = NULL;
230 ASSERT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
233 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l);
235 for (int p = 0; p < prop_count; p++) {
237 value.s32 = TDM_UT_INVALID_VALUE;
238 ASSERT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
239 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
240 "Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().",
247 TEST_P(TDMBackendBasic, VerifyOutputSetMode)
249 for (int o = 0; o < output_count; o++) {
250 const tdm_output_mode *got_mode = NULL;
251 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
252 const tdm_output_mode *set_mode = NULL;
253 const tdm_output_mode *best = NULL;
254 int count = TDM_UT_INVALID_VALUE;
256 if (!ut_tdm_output_is_connected(outputs[o]))
259 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
260 TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
261 TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
263 for (int i = 0; i < count; i++) {
266 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
267 set_mode = &modes[i];
269 if (!set_mode && best)
271 ASSERT_NE(set_mode, NULL);
273 ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
274 ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
275 TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()");
279 TEST_P(TDMBackendBasic, VerifyOutputSetDpms)
281 for (int o = 0; o < output_count; o++) {
282 const tdm_output_mode *got_mode = NULL;
283 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
284 const tdm_output_mode *set_mode = NULL;
285 const tdm_output_mode *best = NULL;
286 int count = TDM_UT_INVALID_VALUE;
287 tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF;
288 tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON;
290 if (!ut_tdm_output_is_connected(outputs[o]))
293 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
295 ASSERT_NE(modes, NULL);
297 for (int i = 0; i < count; i++) {
300 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
301 set_mode = &modes[i];
303 if (!set_mode && best)
306 ASSERT_NE(set_mode, NULL);
307 ASSERT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
308 ASSERT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
309 ASSERT_EQ(set_mode, got_mode);
311 ASSERT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
312 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
313 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()");
317 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame)
319 for (int o = 0; o < output_count; o++) {
322 if (!ut_tdm_output_is_connected(outputs[o]))
325 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
326 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
328 layer = ut_tdm_output_get_primary_layer(outputs[o]);
329 ASSERT_NE(layer, NULL);
332 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
333 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
336 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
338 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
340 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
341 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
346 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames)
348 for (int o = 0; o < output_count; o++) {
352 if (!ut_tdm_output_is_connected(outputs[o]))
355 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
356 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
358 layer = ut_tdm_output_get_primary_layer(outputs[o]);
359 ASSERT_NE(layer, NULL);
362 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
364 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
365 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
366 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
367 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
368 usleep(40000); /* 40 ms */
370 if (next_buffer == 3)
376 TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o);
378 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
379 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
384 _ut_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence,
385 unsigned int tv_sec, unsigned int tv_usec,
388 bool *done = (bool*)user_data;
393 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler)
395 for (int o = 0; o < output_count; o++) {
398 if (!ut_tdm_output_is_connected(outputs[o]))
401 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
402 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
404 layer = ut_tdm_output_get_primary_layer(outputs[o]);
405 ASSERT_NE(layer, NULL);
408 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
409 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
413 TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE,
414 "Check output_commit(), output_set_commit_handler()");
416 TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
417 "Check display_get_fd(), display_handle_events()");
419 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
421 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
422 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
426 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame)
428 for (int o = 0; o < output_count; o++) {
431 if (!ut_tdm_output_is_connected(outputs[o]))
434 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
435 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
437 layer = ut_tdm_output_get_primary_layer(outputs[o]);
438 ASSERT_NE(layer, NULL);
440 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
441 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
444 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
445 usleep(40000); /* 40 ms */
448 for (int l = 0; l < layer_count; l++) {
451 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
453 ASSERT_EQ(ret, TDM_ERROR_NONE);
454 if (ut_tdm_layer_is_primary_layer(layers[l]))
456 if (ut_tdm_layer_is_cursor_layer(layers[l]))
458 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
459 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true);
463 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
465 TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o);
467 for (int l = 0; l < layer_count; l++)
468 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
469 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
473 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames)
475 for (int o = 0; o < output_count; o++) {
478 if (!ut_tdm_output_is_connected(outputs[o]))
481 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
482 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
484 layer = ut_tdm_output_get_primary_layer(outputs[o]);
485 ASSERT_NE(layer, NULL);
487 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
488 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
491 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
492 usleep(40000); /* 40 ms */
494 for (int l = 0; l < layer_count; l++) {
498 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
500 ASSERT_EQ(ret, TDM_ERROR_NONE);
501 if (ut_tdm_layer_is_primary_layer(layers[l]))
503 if (ut_tdm_layer_is_cursor_layer(layers[l]))
507 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
509 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
510 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
511 ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
512 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
513 usleep(40000); /* 40 ms */
515 if (next_buffer == 3)
521 TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l);
523 ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
524 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
525 usleep(40000); /* 40 ms */
530 TEST_P(TDMBackendBasic, DISABLED_VerifyCursorLayer)
535 _ut_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence,
536 unsigned int tv_sec, unsigned int tv_usec,
539 bool *done = (bool*)user_data;
544 TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
546 for (int o = 0; o < output_count; o++) {
549 if (!ut_tdm_output_is_connected(outputs[o]))
552 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
553 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
555 layer = ut_tdm_output_get_primary_layer(outputs[o]);
556 ASSERT_NE(layer, NULL);
558 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
559 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
562 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
565 for (int t = 1; t < 10; t++) {
566 double start, end, interval;
569 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
572 start = tdm_helper_get_time();
573 TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE,
574 "Check output_wait_vblank(), output_set_vblank_handler()");
576 TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
577 "Check display_get_fd(), display_handle_events()");
578 end = tdm_helper_get_time();
580 /* "+ interval" consider the delay of socket communication between kernel and platform */
581 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
582 "The vblank event should happen after %d vsync intervals(%d ms).\n"
583 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
584 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
585 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
586 "The vblank event should happen after %d vsync intervals(%d ms).\n"
587 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
588 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
594 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
596 for (int o = 0; o < output_count; o++) {
599 if (!ut_tdm_output_is_connected(outputs[o]))
602 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
603 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
605 layer = ut_tdm_output_get_primary_layer(outputs[o]);
606 ASSERT_NE(layer, NULL);
608 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
609 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
612 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
615 for (int t = 1; t < 10; t++) {
616 double start, end, interval;
619 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
622 start = tdm_helper_get_time();
623 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
625 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
626 end = tdm_helper_get_time();
628 /* "+ interval" consider the delay of socket communication between kernel and platform */
629 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
630 "The vblank event should happen after %d vsync intervals(%d ms).\n"
631 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
632 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
633 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
634 "The vblank event should happen after %d vsync intervals(%d ms).\n"
635 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
636 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
641 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
643 for (int o = 0; o < output_count; o++) {
646 if (!ut_tdm_output_is_connected(outputs[o]))
649 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
650 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
652 layer = ut_tdm_output_get_primary_layer(outputs[o]);
653 ASSERT_NE(layer, NULL);
655 ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
656 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true);
659 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
662 for (int t = 1; t < 10; t++) {
663 double start, end, interval;
664 bool done1, done2, done3;
666 interval = ut_tdm_output_get_vblank_interval_time(outputs[o]);
668 done1 = done2 = done3 = false;
669 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
670 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
671 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
672 start = tdm_helper_get_time();
673 while (!done1 || !done2 || !done3)
674 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
675 end = tdm_helper_get_time();
677 /* "+ interval" consider the delay of socket communication between kernel and platform */
678 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
679 "The vblank event should happen after %d vsync intervals(%d ms).\n"
680 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
681 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
682 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
683 "The vblank event should happen after %d vsync intervals(%d ms).\n"
684 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
685 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
690 TEST_P(TDMBackendBasic, VerifyPPObject)
695 if (!ut_tdm_display_has_pp_capability(dpy)) {
696 TDM_UT_INFO("PP not supported");
700 pp = tdm_display_create_pp(dpy, &ret);
701 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "can't create a PP object. Check display_create_pp()");
702 TDM_UT_ASSERT_TRUE(pp != NULL, "can't create a PP object. Check display_create_pp()");
707 TEST_P(TDMBackendBasic, VerifyPPCapabilities)
709 tdm_pp_capability capabilities = (tdm_pp_capability)0;
711 if (!ut_tdm_display_has_pp_capability(dpy)) {
712 TDM_UT_INFO("PP not supported");
716 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE,
717 "Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
718 TDM_UT_ASSERT_TRUE(capabilities != (tdm_pp_capability)0,
719 "PP has no capability. Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
722 TEST_P(TDMBackendBasic, VerifyPPAvaiableSize)
724 if (!ut_tdm_display_has_pp_capability(dpy)) {
725 TDM_UT_INFO("PP not supported");
733 int preferred_align = 0;
734 ASSERT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
739 ASSERT_NE(preferred_align, 0);
742 TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
744 if (!ut_tdm_display_has_pp_capability(dpy)) {
745 TDM_UT_INFO("PP not supported");
749 const tbm_format *formats = NULL;
750 int format_count = 0;
751 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
752 "Check display_get_pp_capability(), tdm_caps_pp");
753 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_pp_capability(), tdm_caps_pp.");
754 TDM_UT_ASSERT_TRUE(format_count > 0, "Format count should be greater than 0. Check display_get_pp_capability(), tdm_caps_pp.");
757 TEST_P(TDMBackendBasic, VerifyCaptureObject)
759 if (!ut_tdm_display_has_capture_capability(dpy)) {
760 TDM_UT_INFO("Capture not supported.");
764 for (int o = 0; o < output_count; o++) {
765 tdm_capture *capture;
768 unsigned int has_capability = 0;
769 ASSERT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
770 if (!has_capability) {
771 TDM_UT_INFO("Capture not supported. (output: %d)", o);
775 if (!ut_tdm_output_is_connected(outputs[o]))
778 capture = tdm_output_create_capture(outputs[o], &ret);
779 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "Can't create a capture object. Check output_create_capture().");
780 TDM_UT_ASSERT_TRUE(capture != NULL, "Can't create a capture object. Check output_create_capture().");
782 tdm_capture_destroy(capture);
786 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize)
788 if (!ut_tdm_display_has_capture_capability(dpy)) {
789 TDM_UT_INFO("Capture not supported.");
797 int preferred_align = 0;
798 ASSERT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
803 ASSERT_NE(preferred_align, 0);
806 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
808 if (!ut_tdm_display_has_capture_capability(dpy)) {
809 TDM_UT_INFO("Capture not supported.");
813 const tbm_format *formats = NULL;
814 int format_count = 0;
815 TDM_UT_ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
816 "Check display_get_capture_capability(), tdm_caps_capture.");
817 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_capture_capability(), tdm_caps_capture.");
818 TDM_UT_ASSERT_TRUE(format_count > 0, "The format count should be greater than 0. Check display_get_capture_capability(), tdm_caps_capture.");
821 #ifdef TDM_UT_TEST_WITH_PARAMS
822 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
824 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
826 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
828 Values(TDM_DEFAULT_MODULE));
831 TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat)
833 for (int o = 0; o < output_count; o++) {
838 const tbm_format *formats;
839 int format_count = 0;
840 const tdm_output_mode *mode = NULL;
841 unsigned int flags = 0;
843 if (!ut_tdm_output_is_connected(outputs[o]))
846 layer = ut_tdm_output_get_primary_layer(outputs[o]);
847 ASSERT_NE(layer, NULL);
849 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
850 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
852 for (int f = 0; f < format_count; f++) {
853 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
854 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
855 ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
856 ASSERT_NE(mode, NULL);
859 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
860 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
862 /* set buffer & commit for 60 times */
863 for (int t = 0; t < 60; t++) {
864 tbm_surface_h displaying_buffer;
865 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
867 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
869 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
870 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
871 ASSERT_EQ(ret, TDM_ERROR_NONE);
872 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
874 if (next_buffer == 3)
880 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a primary layer? (output: %d)", FOURCC_STR(formats[f]), o);
885 TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
887 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
889 for (int l = 0; l < layer_count; l++) {
895 const tbm_format *formats;
896 int format_count = 0;
897 const tdm_output_mode *mode = NULL;
898 unsigned int flags = 0;
899 unsigned int pipe = 0;
903 output = tdm_layer_get_output(layer, &ret);
904 ASSERT_EQ(ret, TDM_ERROR_NONE);
906 if (!ut_tdm_output_is_connected(output))
908 if (ut_tdm_layer_is_primary_layer(layer))
910 if (ut_tdm_layer_is_cursor_layer(layer))
913 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
915 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
917 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
918 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
919 ASSERT_NE(mode, NULL);
921 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
923 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
925 for (int f = 0; f < format_count; f++) {
927 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
928 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
930 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
931 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
932 tbm_surface_h displaying_buffer;
933 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
935 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
937 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
938 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
939 ASSERT_EQ(ret, TDM_ERROR_NONE);
940 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
942 if (next_buffer == 3)
946 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);
951 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
955 TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
957 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
959 for (int l = 0; l < layer_count; l++) {
965 const tbm_format *formats;
966 int format_count = 0;
967 const tdm_output_mode *mode = NULL;
968 unsigned int flags = 0;
969 unsigned int pipe = 0;
973 output = tdm_layer_get_output(layer, &ret);
974 ASSERT_EQ(ret, TDM_ERROR_NONE);
976 if (!ut_tdm_output_is_connected(output))
978 if (ut_tdm_layer_is_primary_layer(layer))
980 if (ut_tdm_layer_is_cursor_layer(layer))
983 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
985 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
987 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
988 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
989 ASSERT_NE(mode, NULL);
991 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
993 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
995 for (int f = 0; f < format_count; f++) {
996 int diffw = mode->hdisplay / (format_count + 2);
997 int diffh = mode->vdisplay / (format_count + 2);
998 int w = mode->hdisplay - diffw * (f + 1);
999 int h = mode->vdisplay - diffh * (f + 1);
1001 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1002 ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1004 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1005 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1006 tbm_surface_h displaying_buffer;
1007 ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
1009 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1011 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1012 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1013 ASSERT_EQ(ret, TDM_ERROR_NONE);
1014 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1016 if (next_buffer == 3)
1022 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' small size(%dx%d) frames to a layer? (output: %d, layer: %d)",
1023 FOURCC_STR(formats[f]), w, h, pipe, l);
1026 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1030 TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
1032 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1034 for (int l = 0; l < layer_count; l++) {
1038 int next_buffer = 0;
1040 const tbm_format *formats;
1041 int format_count = 0;
1042 const tdm_output_mode *mode = NULL;
1043 unsigned int flags = 0;
1044 unsigned int pipe = 0;
1048 output = tdm_layer_get_output(layer, &ret);
1049 ASSERT_EQ(ret, TDM_ERROR_NONE);
1051 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1053 if (!ut_tdm_output_is_connected(output))
1055 if (ut_tdm_layer_is_primary_layer(layer))
1057 if (ut_tdm_layer_is_cursor_layer(layer))
1059 if (!ut_tdm_layer_support_scale(layer)) {
1060 TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l);
1064 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1065 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1066 ASSERT_NE(mode, NULL);
1068 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1070 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1072 for (int f = 0; f < format_count; f++) {
1074 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
1075 ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1077 tdm_info_layer info;
1078 memset(&info, 0, sizeof info);
1079 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1080 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1081 info.src_config.pos.x = 0;
1082 info.src_config.pos.y = 0;
1083 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1084 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1085 info.src_config.format = formats[f];
1088 info.dst_pos.w = mode->hdisplay;
1089 info.dst_pos.h = mode->vdisplay;
1090 info.transform = TDM_TRANSFORM_NORMAL;
1091 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1093 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1094 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1095 tbm_surface_h displaying_buffer;
1096 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1098 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1100 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1101 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1102 ASSERT_EQ(ret, TDM_ERROR_NONE);
1103 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1105 if (next_buffer == 3)
1111 TDM_UT_ASK_YNR("* Successed to scale '%c%c%c%c' small size(%dx%d) frames to fullsreen? (output: %d, layer: %d)",
1112 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1115 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1119 TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
1121 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1123 for (int l = 0; l < layer_count; l++) {
1127 int next_buffer = 0;
1129 const tbm_format *formats;
1130 int format_count = 0;
1131 const tdm_output_mode *mode = NULL;
1132 unsigned int flags = 0;
1133 unsigned int pipe = 0;
1137 output = tdm_layer_get_output(layer, &ret);
1138 ASSERT_EQ(ret, TDM_ERROR_NONE);
1140 if (!ut_tdm_output_is_connected(output))
1142 if (ut_tdm_layer_is_primary_layer(layer))
1144 if (ut_tdm_layer_is_cursor_layer(layer))
1147 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1149 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1151 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1152 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1153 ASSERT_NE(mode, NULL);
1155 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1157 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1159 for (int f = 0; f < format_count; f++) {
1161 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1162 ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1164 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1165 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1166 tbm_surface_h displaying_buffer;
1168 tdm_info_layer info;
1169 memset(&info, 0, sizeof info);
1170 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1171 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1172 info.src_config.pos.x = 0;
1173 info.src_config.pos.y = 0;
1174 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1175 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1176 info.src_config.format = formats[f];
1177 info.dst_pos.x = ((mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1178 info.dst_pos.y = ((mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1179 info.dst_pos.w = TDM_UT_BUFFER_SIZE;
1180 info.dst_pos.h = TDM_UT_BUFFER_SIZE;
1181 info.transform = TDM_TRANSFORM_NORMAL;
1182 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1184 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1186 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1188 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1189 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1190 ASSERT_EQ(ret, TDM_ERROR_NONE);
1191 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1193 if (next_buffer == 3)
1199 TDM_UT_ASK_YNR("* Successed to move '%c%c%c%c' small size(%dx%d) frames on screen? (output: %d, layer: %d)",
1200 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1203 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1207 TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
1209 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1211 for (int l = 0; l < layer_count; l++) {
1215 int next_buffer = 0;
1217 const tbm_format *formats;
1218 int format_count = 0;
1219 const tdm_output_mode *mode = NULL;
1220 unsigned int flags = 0;
1221 unsigned int pipe = 0;
1225 output = tdm_layer_get_output(layer, &ret);
1226 ASSERT_EQ(ret, TDM_ERROR_NONE);
1228 ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1230 if (!ut_tdm_output_is_connected(output))
1232 if (ut_tdm_layer_is_primary_layer(layer))
1234 if (ut_tdm_layer_is_cursor_layer(layer))
1236 if (ut_tdm_layer_support_no_crop(layer)) {
1237 TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l);
1241 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1243 ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1244 ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1245 ASSERT_NE(mode, NULL);
1247 ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1249 ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1251 for (int f = 0; f < format_count; f++) {
1253 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1254 ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1256 tdm_info_layer info;
1257 memset(&info, 0, sizeof info);
1258 info.src_config.size.h = mode->hdisplay;
1259 info.src_config.size.v = mode->vdisplay;
1260 info.src_config.pos.x = mode->hdisplay / 2;
1261 info.src_config.pos.y = mode->vdisplay / 2;
1262 info.src_config.pos.w = info.src_config.size.h / 2;
1263 info.src_config.pos.h = info.src_config.size.v / 2;
1264 info.src_config.format = formats[f];
1265 info.dst_pos.x = info.src_config.pos.x;
1266 info.dst_pos.y = info.src_config.pos.y;
1267 info.dst_pos.w = info.src_config.pos.w;
1268 info.dst_pos.h = info.src_config.pos.h;
1269 info.transform = TDM_TRANSFORM_NORMAL;
1270 ASSERT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1272 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1273 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1274 tbm_surface_h displaying_buffer;
1275 ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1277 ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1279 ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1280 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1281 ASSERT_EQ(ret, TDM_ERROR_NONE);
1282 ASSERT_EQ(displaying_buffer, buffers[next_buffer]);
1284 if (next_buffer == 3)
1290 TDM_UT_ASK_YNR("* Successed to crop '%c%c%c%c' frames and display it? (output: %d, layer: %d)",
1291 FOURCC_STR(formats[f]), pipe, l);
1294 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1298 /* should be debugged int emulator kernel */
1299 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
1301 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1303 for (int o = 0; o < output_count; o++) {
1304 if (!ut_tdm_output_is_connected(outputs[o]))
1307 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1311 /* should be debugged int emulator kernel */
1312 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
1314 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1316 for (int o = 0; o < output_count; o++) {
1317 if (!ut_tdm_output_is_connected(outputs[o]))
1320 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1321 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1325 /* should be debugged int emulator kernel */
1326 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet)
1328 for (int o = 0; o < output_count; o++) {
1329 if (!ut_tdm_output_is_connected(outputs[o]))
1332 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
1333 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1337 /* should be debugged int emulator kernel */
1338 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet)
1340 for (int o = 0; o < output_count; o++) {
1341 if (!ut_tdm_output_is_connected(outputs[o]))
1344 ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true);
1345 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1349 /* should be debugged int emulator kernel */
1350 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit)
1352 for (int o = 0; o < output_count; o++) {
1353 if (!ut_tdm_output_is_connected(outputs[o]))
1356 ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
1358 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1359 ASSERT_NE(layer, NULL);
1361 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1363 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1367 /* should be debugged int emulator kernel */
1368 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit)
1370 for (int o = 0; o < output_count; o++) {
1371 if (!ut_tdm_output_is_connected(outputs[o]))
1374 ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true);
1376 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1377 ASSERT_NE(layer, NULL);
1379 ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1380 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1382 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1386 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync)
1390 TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
1392 ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1394 for (int o = 0; o < output_count; o++) {
1395 if (!ut_tdm_output_is_connected(outputs[o]))
1398 tbm_surface_h displaying_buffer;
1400 tdm_info_layer info, temp;
1401 tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]);
1402 ASSERT_NE(layer, NULL);
1404 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1405 ASSERT_NE(displaying_buffer, NULL);
1406 ASSERT_EQ(ret, TDM_ERROR_NONE);
1407 ASSERT_EQ(ut_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
1408 ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
1409 ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0);
1413 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputWaitVblankBeforeDpmsOff) /* TODO */
1417 TEST_P(TDMBackendDisplay, DISABLED_VerifyLayerSetVideoPos)
1421 #ifdef TDM_UT_TEST_WITH_PARAMS
1422 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1424 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1426 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1428 Values(TDM_DEFAULT_MODULE));