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 TDM_UT_BACKEND_TEST_CNT 20
37 TDMBackendBasic::TDMBackendBasic()
45 for (int b = 0; b < 3; b++)
49 void TDMBackendBasic::SetUp(void)
53 TDMBackendEnv::SetUp();
55 dpy = tdm_display_init(&ret);
56 EXPECT_EQ(ret, TDM_ERROR_NONE);
59 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
60 EXPECT_GE(output_count, 0);
62 if (output_count > 0) {
63 outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
64 EXPECT_NE(outputs, NULL);
66 for (int o = 0; o < output_count; o++) {
68 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
69 EXPECT_EQ(ret, TDM_ERROR_NONE);
70 EXPECT_NE(output, NULL);
75 for (int o = 0; o < output_count; o++) {
76 int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE;
79 if (tc_tdm_output_is_hwc_enable(outputs[o]))
82 EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
86 layers = (tdm_layer**)realloc(layers, layer_count * sizeof(tdm_layer*));
87 EXPECT_NE(layers, NULL);
89 for (int l = 0; l < count; l++) {
90 tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
91 EXPECT_NE(layer, NULL);
92 EXPECT_EQ(ret, TDM_ERROR_NONE);
93 layers[old_layer_count + l] = layer;
98 void TDMBackendBasic::TearDown(void)
100 tdm_display_deinit(dpy);
113 EXPECT_EQ(tbm_bufmgr_debug_get_ref_count(), 0);
115 TDMBackendEnv::TearDown();
118 void TDMBackendBasic::DestroyBuffers(void)
120 for (int b = 0; b < 3; b++) {
122 tbm_surface_destroy(buffers[b]);
128 tc_tdm_backend_getchar(void)
133 if (ch == '\n' || ch == '\r')
138 while (c != '\n' && c != EOF)
144 TEST_P(TDMBackendBasic, VerifyOutputObject)
147 int output_count = 0;
149 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
150 TDM_UT_ASSERT_TRUE(output_count > 0, "output count(%d) should be greater than 0. Check display_get_outputs().");
152 for (int o = 0; o < output_count; o++) {
153 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
154 EXPECT_EQ(ret, TDM_ERROR_NONE);
155 TDM_UT_ASSERT_TRUE(output != NULL, "no output. (output: %d). Check display_get_outputs().", o);
159 TEST_P(TDMBackendBasic, VerifyLayerObject)
162 int output_count = 0;
164 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
166 for (int o = 0; o < output_count; o++) {
167 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
168 EXPECT_EQ(ret, TDM_ERROR_NONE);
170 if (tc_tdm_output_is_hwc_enable(outputs[o]))
174 EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
175 TDM_UT_ASSERT_TRUE(layer_count > 0,
176 "layer count(%d) should be greater than 0. (output: %d). Check output_get_layers().",
179 for (int l = 0; l < layer_count; l++) {
180 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
181 TDM_UT_ASSERT_TRUE(layer != NULL, "no layer. (output: %d, layer: %d). Check output_get_layers().", o, l);
186 TEST_P(TDMBackendBasic, VerifyOutputGetProperty)
189 int output_count = 0;
191 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
193 for (int o = 0; o < output_count; o++) {
194 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
195 EXPECT_EQ(ret, TDM_ERROR_NONE);
197 const tdm_prop *props = NULL;
199 EXPECT_EQ(tdm_output_get_available_properties(output, &props, &prop_count), TDM_ERROR_NONE);
202 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d). Check output_get_capability(), tdm_caps_output.", o);
204 for (int p = 0; p < prop_count; p++) {
206 value.s32 = TDM_UT_INVALID_VALUE;
207 EXPECT_EQ(tdm_output_get_property(output, props[p].id, &value), TDM_ERROR_NONE);
208 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
209 "Getting a prop failed. (output: %d, prop_id: %d). Check output_get_property().",
215 TEST_P(TDMBackendBasic, VerifyLayerGetProperty)
218 int output_count = 0;
220 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
222 for (int o = 0; o < output_count; o++) {
223 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
224 EXPECT_EQ(ret, TDM_ERROR_NONE);
226 if (tc_tdm_output_is_hwc_enable(outputs[o]))
230 EXPECT_EQ(tdm_output_get_layer_count(output, &layer_count), TDM_ERROR_NONE);
232 for (int l = 0; l < layer_count; l++) {
233 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
234 EXPECT_EQ(ret, TDM_ERROR_NONE);
236 const tdm_prop *props = NULL;
238 EXPECT_EQ(tdm_layer_get_available_properties(layer, &props, &prop_count), TDM_ERROR_NONE);
241 TDM_UT_ASSERT_TRUE(props != NULL, "no props. (output: %d, layer: %d). Check output_get_capability(), tdm_caps_output.", o, l);
243 for (int p = 0; p < prop_count; p++) {
245 value.s32 = TDM_UT_INVALID_VALUE;
246 EXPECT_EQ(tdm_layer_get_property(layer, props[p].id, &value), TDM_ERROR_NONE);
247 TDM_UT_ASSERT_TRUE(value.s32 != TDM_UT_INVALID_VALUE,
248 "Getting a prop failed. (output: %d, layer: %d, prop_id: %d). Check output_get_property().",
255 TEST_P(TDMBackendBasic, VerifyOutputSetMode)
257 for (int o = 0; o < output_count; o++) {
258 const tdm_output_mode *got_mode = NULL;
259 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
260 const tdm_output_mode *set_mode = NULL;
261 const tdm_output_mode *best = NULL;
262 int count = TDM_UT_INVALID_VALUE;
264 if (!tc_tdm_output_is_connected(outputs[o]))
267 EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
268 TDM_UT_ASSERT_TRUE(count > 0, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
269 TDM_UT_ASSERT_TRUE(modes != NULL, "mode's count should be greater than 0. Check output_get_capability(), tdm_caps_output.");
271 for (int i = 0; i < count; i++) {
274 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
275 set_mode = &modes[i];
277 if (!set_mode && best)
279 EXPECT_NE(set_mode, NULL);
281 EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
282 EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
283 TDM_UT_ASSERT_TRUE(set_mode == got_mode, "The mode which is set and got are different. Check output_set_mode(), output_get_mode()");
287 TEST_P(TDMBackendBasic, VerifyOutputSetDpms)
289 for (int o = 0; o < output_count; o++) {
290 const tdm_output_mode *got_mode = NULL;
291 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
292 const tdm_output_mode *set_mode = NULL;
293 const tdm_output_mode *best = NULL;
294 int count = TDM_UT_INVALID_VALUE;
295 tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF;
296 tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON;
298 if (!tc_tdm_output_is_connected(outputs[o]))
301 EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
303 EXPECT_NE(modes, NULL);
305 for (int i = 0; i < count; i++) {
308 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
309 set_mode = &modes[i];
311 if (!set_mode && best)
314 EXPECT_NE(set_mode, NULL);
315 EXPECT_EQ(tdm_output_set_mode(outputs[o], set_mode), TDM_ERROR_NONE);
316 EXPECT_EQ(tdm_output_get_mode(outputs[o], &got_mode), TDM_ERROR_NONE);
317 EXPECT_EQ(set_mode, got_mode);
319 EXPECT_EQ(tdm_output_set_dpms(outputs[o], set_dpms), TDM_ERROR_NONE);
320 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &got_dpms), TDM_ERROR_NONE);
321 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()");
325 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame)
327 for (int o = 0; o < output_count; o++) {
330 if (!tc_tdm_output_is_connected(outputs[o]))
333 if (tc_tdm_output_is_hwc_enable(outputs[o]))
336 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
337 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
339 layer = tc_tdm_output_get_primary_layer(outputs[o]);
340 EXPECT_NE(layer, NULL);
343 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
344 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
347 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
349 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
351 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
352 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
357 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames)
359 for (int o = 0; o < output_count; o++) {
363 if (!tc_tdm_output_is_connected(outputs[o]))
366 if (tc_tdm_output_is_hwc_enable(outputs[o]))
369 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
370 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
372 layer = tc_tdm_output_get_primary_layer(outputs[o]);
373 EXPECT_NE(layer, NULL);
376 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true);
378 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
379 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
380 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
381 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
382 usleep(40000); /* 40 ms */
384 if (next_buffer == 3)
390 TDM_UT_ASK_YNR("* Successed to display many frames to a primary layer? (output: %d)", o);
392 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
393 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
398 _tc_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence,
399 unsigned int tv_sec, unsigned int tv_usec,
402 bool *done = (bool*)user_data;
407 TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler)
409 for (int o = 0; o < output_count; o++) {
412 if (!tc_tdm_output_is_connected(outputs[o]))
415 if (tc_tdm_output_is_hwc_enable(outputs[o]))
418 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
419 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
421 layer = tc_tdm_output_get_primary_layer(outputs[o]);
422 EXPECT_NE(layer, NULL);
425 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
426 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
430 TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE,
431 "Check output_commit(), output_set_commit_handler()");
433 TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
434 "Check display_get_fd(), display_handle_events()");
436 TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o);
438 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
439 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
443 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame)
445 for (int o = 0; o < output_count; o++) {
448 if (!tc_tdm_output_is_connected(outputs[o]))
451 if (tc_tdm_output_is_hwc_enable(outputs[o]))
454 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
455 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
457 layer = tc_tdm_output_get_primary_layer(outputs[o]);
458 EXPECT_NE(layer, NULL);
460 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
461 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
464 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
465 usleep(40000); /* 40 ms */
468 for (int l = 0; l < layer_count; l++) {
471 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
473 EXPECT_EQ(ret, TDM_ERROR_NONE);
474 if (tc_tdm_layer_is_primary_layer(layers[l]))
476 if (tc_tdm_layer_is_cursor_layer(layers[l]))
478 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
479 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
483 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
485 TDM_UT_ASK_YNR("* Successed to display frames to all overlay layers? (output: %d)", o);
487 for (int l = 0; l < layer_count; l++)
488 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
489 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
493 TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames)
495 for (int o = 0; o < output_count; o++) {
498 if (!tc_tdm_output_is_connected(outputs[o]))
501 if (tc_tdm_output_is_hwc_enable(outputs[o]))
504 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
505 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
507 layer = tc_tdm_output_get_primary_layer(outputs[o]);
508 EXPECT_NE(layer, NULL);
510 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true);
511 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
514 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
515 usleep(40000); /* 40 ms */
517 for (int l = 0; l < layer_count; l++) {
521 if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
523 EXPECT_EQ(ret, TDM_ERROR_NONE);
524 if (tc_tdm_layer_is_primary_layer(layers[l]))
526 if (tc_tdm_layer_is_cursor_layer(layers[l]))
530 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true);
532 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
533 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
534 EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true);
535 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
536 usleep(40000); /* 40 ms */
538 if (next_buffer == 3)
544 TDM_UT_ASK_YNR("* Successed to display many frames to a layer? (output: %d, layer: %d)", o, l);
546 EXPECT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE);
547 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
548 usleep(40000); /* 40 ms */
553 TEST_P(TDMBackendBasic, DISABLED_VerifyCursorLayer)
558 _tc_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence,
559 unsigned int tv_sec, unsigned int tv_usec,
562 bool *done = (bool*)user_data;
567 TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
569 for (int o = 0; o < output_count; o++) {
572 if (!tc_tdm_output_is_connected(outputs[o]))
575 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
576 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
578 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
579 layer = tc_tdm_output_get_primary_layer(outputs[o]);
580 EXPECT_NE(layer, NULL);
582 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
583 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
586 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
590 for (int t = 1; t < 10; t++) {
591 double start, end, interval;
594 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
597 start = tdm_helper_get_time();
598 TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE,
599 "Check output_wait_vblank(), output_set_vblank_handler()");
601 TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE,
602 "Check display_get_fd(), display_handle_events()");
603 end = tdm_helper_get_time();
605 /* "+ interval" consider the delay of socket communication between kernel and platform */
606 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
607 "The vblank event should happen after %d vsync intervals(%d ms).\n"
608 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
609 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
610 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
611 "The vblank event should happen after %d vsync intervals(%d ms).\n"
612 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
613 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
619 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
621 for (int o = 0; o < output_count; o++) {
624 if (!tc_tdm_output_is_connected(outputs[o]))
627 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
628 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
630 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
631 layer = tc_tdm_output_get_primary_layer(outputs[o]);
632 EXPECT_NE(layer, NULL);
634 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
635 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
638 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
642 for (int t = 1; t < 10; t++) {
643 double start, end, interval;
646 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
649 start = tdm_helper_get_time();
650 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE);
652 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
653 end = tdm_helper_get_time();
655 /* "+ interval" consider the delay of socket communication between kernel and platform */
656 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
657 "The vblank event should happen after %d vsync intervals(%d ms).\n"
658 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
659 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
660 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
661 "The vblank event should happen after %d vsync intervals(%d ms).\n"
662 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
663 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
668 TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
670 for (int o = 0; o < output_count; o++) {
673 if (!tc_tdm_output_is_connected(outputs[o]))
676 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
677 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
679 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
680 layer = tc_tdm_output_get_primary_layer(outputs[o]);
681 EXPECT_NE(layer, NULL);
683 EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
684 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
687 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
691 for (int t = 1; t < 10; t++) {
692 double start, end, interval;
693 bool done1, done2, done3;
695 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
697 done1 = done2 = done3 = false;
698 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE);
699 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE);
700 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE);
701 start = tdm_helper_get_time();
702 while (!done1 || !done2 || !done3)
703 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
704 end = tdm_helper_get_time();
706 /* "+ interval" consider the delay of socket communication between kernel and platform */
707 TDM_UT_ASSERT_TRUE((end - start) > (interval * (t - 1)),
708 "The vblank event should happen after %d vsync intervals(%d ms).\n"
709 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
710 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
711 TDM_UT_ASSERT_TRUE((end - start) < (interval * t + interval),
712 "The vblank event should happen after %d vsync intervals(%d ms).\n"
713 "\t But it happened at %d ms. Check output_wait_vblank(), output_set_vblank_handler()",
714 t, (int)(t * interval * 1000), (int)((end - start) * 1000));
719 TEST_P(TDMBackendBasic, VerifyPPObject)
724 if (!tc_tdm_display_has_pp_capability(dpy)) {
725 TDM_UT_INFO("PP not supported");
729 pp = tdm_display_create_pp(dpy, &ret);
730 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "can't create a PP object. Check display_create_pp()");
731 TDM_UT_ASSERT_TRUE(pp != NULL, "can't create a PP object. Check display_create_pp()");
736 TEST_P(TDMBackendBasic, VerifyPPCapabilities)
738 tdm_pp_capability capabilities = (tdm_pp_capability)0;
740 if (!tc_tdm_display_has_pp_capability(dpy)) {
741 TDM_UT_INFO("PP not supported");
745 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_capabilities(dpy, &capabilities) == TDM_ERROR_NONE,
746 "Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
747 TDM_UT_ASSERT_TRUE(capabilities != (tdm_pp_capability)0,
748 "PP has no capability. Check display_get_pp_capability(), tdm_caps_pp, tdm_pp_capability.");
751 TEST_P(TDMBackendBasic, VerifyPPAvaiableSize)
753 if (!tc_tdm_display_has_pp_capability(dpy)) {
754 TDM_UT_INFO("PP not supported");
762 int preferred_align = 0;
763 EXPECT_EQ(tdm_display_get_pp_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
768 EXPECT_NE(preferred_align, 0);
771 TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats)
773 if (!tc_tdm_display_has_pp_capability(dpy)) {
774 TDM_UT_INFO("PP not supported");
778 const tbm_format *formats = NULL;
779 int format_count = 0;
780 TDM_UT_ASSERT_TRUE(tdm_display_get_pp_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
781 "Check display_get_pp_capability(), tdm_caps_pp");
782 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_pp_capability(), tdm_caps_pp.");
783 TDM_UT_ASSERT_TRUE(format_count > 0, "Format count should be greater than 0. Check display_get_pp_capability(), tdm_caps_pp.");
786 TEST_P(TDMBackendBasic, VerifyCaptureObject)
788 if (!tc_tdm_display_has_capture_capability(dpy)) {
789 TDM_UT_INFO("Capture not supported.");
793 for (int o = 0; o < output_count; o++) {
794 tdm_capture *capture;
797 unsigned int has_capability = 0;
798 EXPECT_EQ(tdm_output_has_capture_capability(outputs[o], &has_capability), TDM_ERROR_NONE);
799 if (!has_capability) {
800 TDM_UT_INFO("Capture not supported. (output: %d)", o);
804 if (!tc_tdm_output_is_connected(outputs[o]))
807 capture = tdm_output_create_capture(outputs[o], &ret);
808 TDM_UT_ASSERT_TRUE(ret == TDM_ERROR_NONE, "Can't create a capture object. Check output_create_capture().");
809 TDM_UT_ASSERT_TRUE(capture != NULL, "Can't create a capture object. Check output_create_capture().");
811 tdm_capture_destroy(capture);
815 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize)
817 if (!tc_tdm_display_has_capture_capability(dpy)) {
818 TDM_UT_INFO("Capture not supported.");
826 int preferred_align = 0;
827 EXPECT_EQ(tdm_display_get_capture_available_size(dpy, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
832 EXPECT_NE(preferred_align, 0);
835 TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats)
837 if (!tc_tdm_display_has_capture_capability(dpy)) {
838 TDM_UT_INFO("Capture not supported.");
842 const tbm_format *formats = NULL;
843 int format_count = 0;
844 TDM_UT_ASSERT_TRUE(tdm_display_get_capture_available_formats(dpy, &formats, &format_count) == TDM_ERROR_NONE,
845 "Check display_get_capture_capability(), tdm_caps_capture.");
846 TDM_UT_ASSERT_TRUE(formats != NULL, "Should have a format table. Check display_get_capture_capability(), tdm_caps_capture.");
847 TDM_UT_ASSERT_TRUE(format_count > 0, "The format count should be greater than 0. Check display_get_capture_capability(), tdm_caps_capture.");
850 #ifdef TDM_UT_TEST_WITH_PARAMS
851 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
853 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
855 INSTANTIATE_TEST_CASE_P(TDMBackendBasicParams,
857 Values(TDM_DEFAULT_MODULE));
860 TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat)
862 for (int o = 0; o < output_count; o++) {
867 const tbm_format *formats;
868 int format_count = 0;
869 const tdm_output_mode *mode = NULL;
870 unsigned int flags = 0;
872 if (!tc_tdm_output_is_connected(outputs[o]))
875 if (tc_tdm_output_is_hwc_enable(outputs[o]))
878 layer = tc_tdm_output_get_primary_layer(outputs[o]);
879 EXPECT_NE(layer, NULL);
881 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
882 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
884 for (int f = 0; f < format_count; f++) {
885 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
886 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
887 EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
888 EXPECT_NE(mode, NULL);
891 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
892 EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
894 /* set buffer & commit for 60 times */
895 for (int t = 0; t < 60; t++) {
896 tbm_surface_h displaying_buffer;
897 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
899 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
901 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
902 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
903 EXPECT_EQ(ret, TDM_ERROR_NONE);
904 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
906 if (next_buffer == 3)
912 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a primary layer? (output: %d)", FOURCC_STR(formats[f]), o);
917 TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat)
919 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
921 if (output_count > 0) {
922 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
923 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
928 for (int l = 0; l < layer_count; l++) {
934 const tbm_format *formats;
935 int format_count = 0;
936 const tdm_output_mode *mode = NULL;
937 unsigned int flags = 0;
938 unsigned int pipe = 0;
942 output = tdm_layer_get_output(layer, &ret);
943 EXPECT_EQ(ret, TDM_ERROR_NONE);
945 if (!tc_tdm_output_is_connected(output))
947 if (tc_tdm_layer_is_primary_layer(layer))
949 if (tc_tdm_layer_is_cursor_layer(layer))
952 EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
954 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
956 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
957 EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
958 EXPECT_NE(mode, NULL);
960 EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
962 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
964 for (int f = 0; f < format_count; f++) {
966 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
967 EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
969 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
970 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
971 tbm_surface_h displaying_buffer;
972 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
974 EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
976 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
977 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
978 EXPECT_EQ(ret, TDM_ERROR_NONE);
979 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
981 if (next_buffer == 3)
985 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);
990 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
994 TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize)
996 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
998 if (output_count > 0) {
999 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
1000 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
1001 TDM_UT_SKIP_FLAG(0);
1005 for (int l = 0; l < layer_count; l++) {
1009 int next_buffer = 0;
1011 const tbm_format *formats;
1012 int format_count = 0;
1013 const tdm_output_mode *mode = NULL;
1014 unsigned int flags = 0;
1015 unsigned int pipe = 0;
1019 output = tdm_layer_get_output(layer, &ret);
1020 EXPECT_EQ(ret, TDM_ERROR_NONE);
1022 if (!tc_tdm_output_is_connected(output))
1024 if (tc_tdm_layer_is_primary_layer(layer))
1026 if (tc_tdm_layer_is_cursor_layer(layer))
1029 EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1031 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1033 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1034 EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1035 EXPECT_NE(mode, NULL);
1037 EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1039 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1041 for (int f = 0; f < format_count; f++) {
1042 int diffw = mode->hdisplay / (format_count + 2);
1043 int diffh = mode->vdisplay / (format_count + 2);
1044 int w = mode->hdisplay - diffw * (f + 1);
1045 int h = mode->vdisplay - diffh * (f + 1);
1047 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1048 EXPECT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1050 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1051 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1052 tbm_surface_h displaying_buffer;
1053 EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
1055 EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1057 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1058 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1059 EXPECT_EQ(ret, TDM_ERROR_NONE);
1060 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
1062 if (next_buffer == 3)
1068 TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' small size(%dx%d) frames to a layer? (output: %d, layer: %d)",
1069 FOURCC_STR(formats[f]), w, h, pipe, l);
1072 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1076 TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale)
1078 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1080 if (output_count > 0) {
1081 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
1082 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
1083 TDM_UT_SKIP_FLAG(0);
1087 for (int l = 0; l < layer_count; l++) {
1091 int next_buffer = 0;
1093 const tbm_format *formats;
1094 int format_count = 0;
1095 const tdm_output_mode *mode = NULL;
1096 unsigned int flags = 0;
1097 unsigned int pipe = 0;
1101 output = tdm_layer_get_output(layer, &ret);
1102 EXPECT_EQ(ret, TDM_ERROR_NONE);
1104 EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1106 if (!tc_tdm_output_is_connected(output))
1108 if (tc_tdm_layer_is_primary_layer(layer))
1110 if (tc_tdm_layer_is_cursor_layer(layer))
1112 if (!tc_tdm_layer_support_scale(layer)) {
1113 TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l);
1117 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1118 EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1119 EXPECT_NE(mode, NULL);
1121 EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1123 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1125 for (int f = 0; f < format_count; f++) {
1127 TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
1128 EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1130 tdm_info_layer info;
1131 memset(&info, 0, sizeof info);
1132 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1133 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1134 info.src_config.pos.x = 0;
1135 info.src_config.pos.y = 0;
1136 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1137 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1138 info.src_config.format = formats[f];
1141 info.dst_pos.w = mode->hdisplay;
1142 info.dst_pos.h = mode->vdisplay;
1143 info.transform = TDM_TRANSFORM_NORMAL;
1144 EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1146 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1147 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1148 tbm_surface_h displaying_buffer;
1149 EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1151 EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1153 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1154 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1155 EXPECT_EQ(ret, TDM_ERROR_NONE);
1156 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
1158 if (next_buffer == 3)
1164 TDM_UT_ASK_YNR("* Successed to scale '%c%c%c%c' small size(%dx%d) frames to fullsreen? (output: %d, layer: %d)",
1165 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1168 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1172 TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition)
1174 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1176 if (output_count > 0) {
1177 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
1178 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
1179 TDM_UT_SKIP_FLAG(0);
1183 for (int l = 0; l < layer_count; l++) {
1187 int next_buffer = 0;
1189 const tbm_format *formats;
1190 int format_count = 0;
1191 const tdm_output_mode *mode = NULL;
1192 unsigned int flags = 0;
1193 unsigned int pipe = 0;
1197 output = tdm_layer_get_output(layer, &ret);
1198 EXPECT_EQ(ret, TDM_ERROR_NONE);
1200 if (!tc_tdm_output_is_connected(output))
1202 if (tc_tdm_layer_is_primary_layer(layer))
1204 if (tc_tdm_layer_is_cursor_layer(layer))
1207 EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1209 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1211 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1212 EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1213 EXPECT_NE(mode, NULL);
1215 EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1217 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1219 for (int f = 0; f < format_count; f++) {
1221 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1222 EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1224 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1225 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1226 tbm_surface_h displaying_buffer;
1228 tdm_info_layer info;
1229 memset(&info, 0, sizeof info);
1230 info.src_config.size.h = TDM_UT_BUFFER_SIZE;
1231 info.src_config.size.v = TDM_UT_BUFFER_SIZE;
1232 info.src_config.pos.x = 0;
1233 info.src_config.pos.y = 0;
1234 info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
1235 info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
1236 info.src_config.format = formats[f];
1237 info.dst_pos.x = ((mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1238 info.dst_pos.y = ((mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
1239 info.dst_pos.w = TDM_UT_BUFFER_SIZE;
1240 info.dst_pos.h = TDM_UT_BUFFER_SIZE;
1241 info.transform = TDM_TRANSFORM_NORMAL;
1242 EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1244 EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1246 EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1248 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1249 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1250 EXPECT_EQ(ret, TDM_ERROR_NONE);
1251 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
1253 if (next_buffer == 3)
1259 TDM_UT_ASK_YNR("* Successed to move '%c%c%c%c' small size(%dx%d) frames on screen? (output: %d, layer: %d)",
1260 FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
1263 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1267 TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop)
1269 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true);
1271 if (output_count > 0) {
1272 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
1273 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[0]), true);
1274 TDM_UT_SKIP_FLAG(0);
1278 for (int l = 0; l < layer_count; l++) {
1282 int next_buffer = 0;
1284 const tbm_format *formats;
1285 int format_count = 0;
1286 const tdm_output_mode *mode = NULL;
1287 unsigned int flags = 0;
1288 unsigned int pipe = 0;
1292 output = tdm_layer_get_output(layer, &ret);
1293 EXPECT_EQ(ret, TDM_ERROR_NONE);
1295 EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
1297 if (!tc_tdm_output_is_connected(output))
1299 if (tc_tdm_layer_is_primary_layer(layer))
1301 if (tc_tdm_layer_is_cursor_layer(layer))
1303 if (tc_tdm_layer_support_no_crop(layer)) {
1304 TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l);
1308 TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
1310 EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
1311 EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
1312 EXPECT_NE(mode, NULL);
1314 EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1316 EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
1318 for (int f = 0; f < format_count; f++) {
1320 TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
1321 EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
1323 tdm_info_layer info;
1324 memset(&info, 0, sizeof info);
1325 info.src_config.size.h = mode->hdisplay;
1326 info.src_config.size.v = mode->vdisplay;
1327 info.src_config.pos.x = mode->hdisplay / 2;
1328 info.src_config.pos.y = mode->vdisplay / 2;
1329 info.src_config.pos.w = info.src_config.size.h / 2;
1330 info.src_config.pos.h = info.src_config.size.v / 2;
1331 info.src_config.format = formats[f];
1332 info.dst_pos.x = info.src_config.pos.x;
1333 info.dst_pos.y = info.src_config.pos.y;
1334 info.dst_pos.w = info.src_config.pos.w;
1335 info.dst_pos.h = info.src_config.pos.h;
1336 info.transform = TDM_TRANSFORM_NORMAL;
1337 EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
1339 /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
1340 for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
1341 tbm_surface_h displaying_buffer;
1342 EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
1344 EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
1346 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1347 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1348 EXPECT_EQ(ret, TDM_ERROR_NONE);
1349 EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
1351 if (next_buffer == 3)
1357 TDM_UT_ASK_YNR("* Successed to crop '%c%c%c%c' frames and display it? (output: %d, layer: %d)",
1358 FOURCC_STR(formats[f]), pipe, l);
1361 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1365 /* should be debugged int emulator kernel */
1366 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff)
1368 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1370 for (int o = 0; o < output_count; o++) {
1371 if (!tc_tdm_output_is_connected(outputs[o]))
1374 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1378 /* should be debugged int emulator kernel */
1379 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn)
1381 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1383 for (int o = 0; o < output_count; o++) {
1384 if (!tc_tdm_output_is_connected(outputs[o]))
1387 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1388 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1392 /* should be debugged int emulator kernel */
1393 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet)
1395 for (int o = 0; o < output_count; o++) {
1396 if (!tc_tdm_output_is_connected(outputs[o]))
1399 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
1400 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1404 /* should be debugged int emulator kernel */
1405 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet)
1407 for (int o = 0; o < output_count; o++) {
1408 if (!tc_tdm_output_is_connected(outputs[o]))
1411 EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
1412 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1416 /* should be debugged int emulator kernel */
1417 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit)
1419 for (int o = 0; o < output_count; o++) {
1420 if (!tc_tdm_output_is_connected(outputs[o]))
1423 if (tc_tdm_output_is_hwc_enable(outputs[o]))
1424 TDM_UT_SKIP_FLAG(0);
1426 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1428 tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
1429 EXPECT_NE(layer, NULL);
1431 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1433 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1437 /* should be debugged int emulator kernel */
1438 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit)
1440 for (int o = 0; o < output_count; o++) {
1441 if (!tc_tdm_output_is_connected(outputs[o]))
1444 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1446 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
1447 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
1448 TDM_UT_SKIP_FLAG(0);
1451 tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
1452 EXPECT_NE(layer, NULL);
1454 EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
1455 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1457 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1461 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync)
1465 TEST_P(TDMBackendDisplay, VerifyLayerGetInfo)
1467 EXPECT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true);
1469 for (int o = 0; o < output_count; o++) {
1470 if (!tc_tdm_output_is_connected(outputs[o]))
1473 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
1474 EXPECT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
1475 TDM_UT_SKIP_FLAG(0);
1478 tbm_surface_h displaying_buffer;
1480 tdm_info_layer info, temp;
1481 tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]);
1482 EXPECT_NE(layer, NULL);
1484 displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
1485 EXPECT_NE(displaying_buffer, NULL);
1486 EXPECT_EQ(ret, TDM_ERROR_NONE);
1487 EXPECT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true);
1488 EXPECT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE);
1489 EXPECT_EQ(memcmp(&info, &temp, sizeof info), 0);
1493 TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputWaitVblankBeforeDpmsOff) /* TODO */
1497 TEST_P(TDMBackendDisplay, DISABLED_VerifyLayerSetVideoPos)
1501 #ifdef TDM_UT_TEST_WITH_PARAMS
1502 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1504 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1506 INSTANTIATE_TEST_CASE_P(TDMBackendDisplayParams,
1508 Values(TDM_DEFAULT_MODULE));