layers = NULL;
layer_count = 0;
+ layer_output = NULL;
+ layer_output_pipe = 0;
+ layer_output_mode = NULL;
+ layer_flags = 0;
+ layer_formats = NULL;
+ layer_format_count = 0;
+
for (int b = 0; b < 3; b++)
buffers[b] = NULL;
}
}
}
+bool TDMBackendBasic::PrepareLayer(tdm_layer *layer)
+{
+ tdm_error ret;
+
+ layer_output = NULL;
+ layer_output_pipe = 0;
+ layer_output_mode = NULL;
+ layer_flags = 0;
+ layer_formats = NULL;
+ layer_format_count = 0;
+
+ layer_output = tdm_layer_get_output(layer, &ret);
+ TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(layer_output, &layer_output_pipe) == TDM_ERROR_NONE);
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &layer_flags) == TDM_ERROR_NONE);
+
+ if (tc_tdm_output_is_connected(layer_output)) {
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(layer_output, &layer_output_mode) == TDM_ERROR_NONE);
+ TDM_UT_RETURN_FALSE_IF_FAIL(layer_output_mode != NULL);
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(layer_output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
+ }
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_available_formats(layer, &layer_formats, &layer_format_count) == TDM_ERROR_NONE);
+
+ return true;
+}
+
+bool TDMBackendBasic::PrepareOutputVblank(tdm_output *output)
+{
+ tdm_layer *layer;
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
+
+ if (!tc_tdm_output_is_hwc_enable(output)) {
+ layer = tc_tdm_output_get_primary_layer(output);
+ TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true) == true);
+ TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffers[0]) == true);
+ DestroyBuffers();
+
+ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE);
+ }
+
+ return true;
+}
+
char
tc_tdm_backend_getchar(void)
{
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
EXPECT_EQ(ret, TDM_ERROR_NONE);
- if (tc_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (tc_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
EXPECT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true);
EXPECT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true);
if (tdm_layer_get_output(layers[l], &ret) != outputs[o])
continue;
EXPECT_EQ(ret, TDM_ERROR_NONE);
- if (tc_tdm_layer_is_primary_layer(layers[l]))
+ if (tc_tdm_layer_is_primary_layer(layer))
continue;
- if (tc_tdm_layer_is_cursor_layer(layers[l]))
+ if (tc_tdm_layer_is_cursor_layer(layer))
continue;
retry:
*done = true;
}
+static void
+_tc_tdm_backend_display_print_wait_vblank_info(double start, double end, double interval, int t)
+{
+ /* "+ interval" consider the delay of socket communication between kernel and platform */
+ //EXPECT_GT((end - start), (interval * (t - 1)));
+ double a = end - start;
+ double b = interval * (t - 1);
+ if (a > b) {
+ std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
+ << "Expected: ((end - start) > (interval * (t - 1))), "
+ << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+ std::cout << "\033[0;34m" << " \t The vblank event should happen after "<< t
+ << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+ << "\t But it happened at " << (end - start) * 1000 << " ms. "
+ << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+ }
+
+ //EXPECT_LT((end - start), (interval * t + interval));
+ a = end - start;
+ b = interval * t + interval;
+ if (a < b) {
+ std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
+ << "Expected: ((end - start) < (interval * t + interval)), "
+ << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
+ std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
+ << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
+ << "\t But it happened at " << (end - start) * 1000 << " ms. "
+ << "Check output_wait_vblank(), output_set_vblank_handler().\n";
+ }
+}
+
TEST_P(TDMBackendBasic, VerifyOutputWaitVblank)
{
for (int o = 0; o < output_count; o++) {
- tdm_layer *layer;
-
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- layer = tc_tdm_output_get_primary_layer(outputs[o]);
- EXPECT_NE(layer, NULL);
-
- EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
- DestroyBuffers();
-
- EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
- }
+ EXPECT_EQ(PrepareOutputVblank(outputs[o]), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
"Check display_get_fd(), display_handle_events()");
end = tdm_helper_get_time();
- /* "+ interval" consider the delay of socket communication between kernel and platform */
- //EXPECT_GT((end - start), (interval * (t - 1)));
- double a = end - start;
- double b = interval * (t - 1);
- if (a > b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) > (interval * (t - 1))), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
-
- //EXPECT_LT((end - start), (interval * t + interval));
- a = end - start;
- b = interval * t + interval;
- if (a < b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) < (interval * t + interval)), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
+ _tc_tdm_backend_display_print_wait_vblank_info(start, end, interval, t);
}
}
}
TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval)
{
for (int o = 0; o < output_count; o++) {
- tdm_layer *layer;
-
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- layer = tc_tdm_output_get_primary_layer(outputs[o]);
- EXPECT_NE(layer, NULL);
-
- EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
- DestroyBuffers();
-
- EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
- }
+ EXPECT_EQ(PrepareOutputVblank(outputs[o]), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
- /* "+ interval" consider the delay of socket communication between kernel and platform */
- //EXPECT_GT((end - start), (interval * (t - 1)));
- double a = end - start;
- double b = interval * (t - 1);
- if (a > b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) > (interval * (t - 1))), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << " \t The vblank event should happen after "<< t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
-
- //EXPECT_LT((end - start), (interval * t + interval));
- a = end - start;
- b = interval * t + interval;
- if (a < b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) < (interval * t + interval)), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
+ _tc_tdm_backend_display_print_wait_vblank_info(start, end, interval, t);
}
}
}
TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank)
{
for (int o = 0; o < output_count; o++) {
- tdm_layer *layer;
-
if (!tc_tdm_output_is_connected(outputs[o]))
continue;
- EXPECT_EQ(tc_tdm_output_mode_setting(outputs[o]), true);
- EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
- layer = tc_tdm_output_get_primary_layer(outputs[o]);
- EXPECT_NE(layer, NULL);
-
- EXPECT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true);
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true);
- DestroyBuffers();
-
- EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
- }
+ EXPECT_EQ(PrepareOutputVblank(outputs[o]), true);
/* start from 1 */
for (int t = 1; t < 10; t++) {
EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
end = tdm_helper_get_time();
- /* "+ interval" consider the delay of socket communication between kernel and platform */
- //EXPECT_GT((end - start), (interval * (t - 1)));
- double a = end - start;
- double b = interval * (t - 1);
- if (a > b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) > (interval * (t - 1))), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << "\t The vblank event should happen after "<< t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
-
- //EXPECT_LT((end - start), (interval * t + interval));
- a = end - start;
- b = interval * t + interval;
- if (a < b) {
- std::cout << "\033[0;35m" << "==> Error: " << "\033[0;33m"
- << "Expected: ((end - start) < (interval * t + interval)), "
- << "actual: " << a << " vs " << b << "\033[0;0m" << std::endl;
- std::cout << "\033[0;34m" << "\t The vblank event should happen after " << t
- << " vsync intervals( "<< t * interval * 1000 + interval * 1000 << " ms).\n"
- << "\t But it happened at " << (end - start) * 1000 << " ms. "
- << "Check output_wait_vblank(), output_set_vblank_handler().\n";
- }
+ _tc_tdm_backend_display_print_wait_vblank_info(start, end, interval, t);
}
}
}
Values(TDM_DEFAULT_MODULE));
#endif
+static bool
+_tc_tdm_backend_display_layer_test(tdm_display *dpy, tdm_output *output, tdm_layer *layer, tdm_info_layer *info,
+ tbm_surface_h *buffers, int test_count, bool test_move)
+{
+ int next_buffer = 0;
+ bool done = false;
+ tdm_error ret;
+ int dst_x = 0, dst_y = 0;
+
+ if (info && test_move) {
+ dst_x = info->dst_pos.x;
+ dst_y = info->dst_pos.y;
+ }
+
+ for (int t = 0; t < test_count; t++) {
+ tbm_surface_h displaying_buffer;
+
+ if (info && test_move) {
+ info->dst_pos.x = dst_x * t;
+ info->dst_pos.y = dst_y * t;
+ }
+
+ if (info)
+ EXPECT_EQ(tdm_layer_set_info(layer, info), TDM_ERROR_NONE);
+
+ EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
+ done = false;
+ EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
+ while (!done)
+ EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
+ displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
+ EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
+ next_buffer++;
+ if (next_buffer == 3)
+ next_buffer = 0;
+ }
+
+ return true;
+}
+
TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat)
{
for (int o = 0; o < output_count; o++) {
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- tdm_error ret;
const tbm_format *formats;
int format_count = 0;
const tdm_output_mode *mode = NULL;
TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
- /* set buffer & commit for 60 times */
- for (int t = 0; t < 60; t++) {
- tbm_surface_h displaying_buffer;
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
- done = false;
- EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, outputs[o], layer, NULL, buffers, 60, false), true);
DestroyBuffers();
}
for (int l = 0; l < layer_count; l++) {
- tdm_error ret;
- tdm_output *output;
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- const tbm_format *formats;
- int format_count = 0;
- const tdm_output_mode *mode = NULL;
- unsigned int flags = 0;
- unsigned int pipe = 0;
layer = layers[l];
- output = tdm_layer_get_output(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(PrepareLayer(layer), true);
- if (!tc_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(layer_output))
continue;
if (tc_tdm_layer_is_primary_layer(layer))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
-
- TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
-
- EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- EXPECT_NE(mode, NULL);
+ TDM_UT_INFO("* testing for (output: %d, layer: %d)", layer_output_pipe, l);
- EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
-
- for (int f = 0; f < format_count; f++) {
+ for (int f = 0; f < layer_format_count; f++) {
retry:
- TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(layer_formats[f]));
+ EXPECT_EQ(tc_tdm_buffer_create(layer_output_mode->hdisplay, layer_output_mode->vdisplay, layer_formats[f],
+ layer_flags | TBM_BO_SCANOUT, true, 3, buffers), true);
- /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
- for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- tbm_surface_h displaying_buffer;
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
- done = false;
- EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, layer_output, layer, NULL, buffers, TDM_UT_BACKEND_TEST_CNT, false), true);
- 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);
+ TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' frames to a layer? (output: %d, layer: %d)",
+ FOURCC_STR(layer_formats[f]), layer_output_pipe, l);
DestroyBuffers();
}
}
for (int l = 0; l < layer_count; l++) {
- tdm_error ret;
- tdm_output *output;
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- const tbm_format *formats;
- int format_count = 0;
- const tdm_output_mode *mode = NULL;
- unsigned int flags = 0;
- unsigned int pipe = 0;
layer = layers[l];
- output = tdm_layer_get_output(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(PrepareLayer(layer), true);
- if (!tc_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(layer_output))
continue;
if (tc_tdm_layer_is_primary_layer(layer))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
-
- TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
+ TDM_UT_INFO("* testing for (output: %d, layer: %d)", layer_output_pipe, l);
- EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- EXPECT_NE(mode, NULL);
-
- EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
-
- for (int f = 0; f < format_count; f++) {
- int diffw = mode->hdisplay / (format_count + 2);
- int diffh = mode->vdisplay / (format_count + 2);
- int w = mode->hdisplay - diffw * (f + 1);
- int h = mode->vdisplay - diffh * (f + 1);
+ for (int f = 0; f < layer_format_count; f++) {
+ int diffw = layer_output_mode->hdisplay / (layer_format_count + 2);
+ int diffh = layer_output_mode->vdisplay / (layer_format_count + 2);
+ int w = layer_output_mode->hdisplay - diffw * (f + 1);
+ int h = layer_output_mode->vdisplay - diffh * (f + 1);
retry:
- TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- EXPECT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(layer_formats[f]));
+ EXPECT_EQ(tc_tdm_buffer_create(w, h, layer_formats[f], layer_flags | TBM_BO_SCANOUT, true, 3, buffers), true);
- /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
- for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- tbm_surface_h displaying_buffer;
- EXPECT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true);
- done = false;
- EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, layer_output, layer, NULL, buffers, TDM_UT_BACKEND_TEST_CNT, false), true);
DestroyBuffers();
TDM_UT_ASK_YNR("* Successed to display '%c%c%c%c' small size(%dx%d) frames to a layer? (output: %d, layer: %d)",
- FOURCC_STR(formats[f]), w, h, pipe, l);
+ FOURCC_STR(layer_formats[f]), w, h, layer_output_pipe, l);
}
EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
for (int l = 0; l < layer_count; l++) {
- tdm_error ret;
- tdm_output *output;
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- const tbm_format *formats;
- int format_count = 0;
- const tdm_output_mode *mode = NULL;
- unsigned int flags = 0;
- unsigned int pipe = 0;
layer = layers[l];
- output = tdm_layer_get_output(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(PrepareLayer(layer), true);
- if (!tc_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(layer_output))
continue;
if (tc_tdm_layer_is_primary_layer(layer))
continue;
continue;
}
- EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- EXPECT_NE(mode, NULL);
-
- EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
-
- for (int f = 0; f < format_count; f++) {
+ for (int f = 0; f < layer_format_count; f++) {
retry:
- TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f]));
- EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(layer_formats[f]));
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, layer_formats[f], layer_flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
info.src_config.pos.y = 0;
info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
- info.src_config.format = formats[f];
+ info.src_config.format = layer_formats[f];
info.dst_pos.x = 0;
info.dst_pos.y = 0;
- info.dst_pos.w = mode->hdisplay;
- info.dst_pos.h = mode->vdisplay;
+ info.dst_pos.w = layer_output_mode->hdisplay;
+ info.dst_pos.h = layer_output_mode->vdisplay;
info.transform = TDM_TRANSFORM_NORMAL;
- EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
- /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
- for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- tbm_surface_h displaying_buffer;
- EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
- done = false;
- EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, layer_output, layer, &info, buffers, TDM_UT_BACKEND_TEST_CNT, false), true);
DestroyBuffers();
TDM_UT_ASK_YNR("* Successed to scale '%c%c%c%c' small size(%dx%d) frames to fullsreen? (output: %d, layer: %d)",
- FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
+ FOURCC_STR(layer_formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, layer_output_pipe, l);
}
EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
for (int l = 0; l < layer_count; l++) {
- tdm_error ret;
- tdm_output *output;
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- const tbm_format *formats;
- int format_count = 0;
- const tdm_output_mode *mode = NULL;
- unsigned int flags = 0;
- unsigned int pipe = 0;
layer = layers[l];
- output = tdm_layer_get_output(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
+ EXPECT_EQ(PrepareLayer(layer), true);
- if (!tc_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(layer_output))
continue;
if (tc_tdm_layer_is_primary_layer(layer))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
- EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
-
- TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
-
- EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- EXPECT_NE(mode, NULL);
-
- EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
+ TDM_UT_INFO("* testing for (output: %d, layer: %d)", layer_output_pipe, l);
- for (int f = 0; f < format_count; f++) {
+ for (int f = 0; f < layer_format_count; f++) {
retry:
- TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(layer_formats[f]));
+ EXPECT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, layer_formats[f], layer_flags | TBM_BO_SCANOUT, true, 3, buffers), true);
- /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
- for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- tbm_surface_h displaying_buffer;
-
- tdm_info_layer info;
- memset(&info, 0, sizeof info);
- info.src_config.size.h = TDM_UT_BUFFER_SIZE;
- info.src_config.size.v = TDM_UT_BUFFER_SIZE;
- info.src_config.pos.x = 0;
- info.src_config.pos.y = 0;
- info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
- info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
- info.src_config.format = formats[f];
- info.dst_pos.x = ((mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
- info.dst_pos.y = ((mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT) * t;
- info.dst_pos.w = TDM_UT_BUFFER_SIZE;
- info.dst_pos.h = TDM_UT_BUFFER_SIZE;
- info.transform = TDM_TRANSFORM_NORMAL;
- EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
- done = false;
- EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ tdm_info_layer info;
+ memset(&info, 0, sizeof info);
+ info.src_config.size.h = TDM_UT_BUFFER_SIZE;
+ info.src_config.size.v = TDM_UT_BUFFER_SIZE;
+ info.src_config.pos.x = 0;
+ info.src_config.pos.y = 0;
+ info.src_config.pos.w = TDM_UT_BUFFER_SIZE;
+ info.src_config.pos.h = TDM_UT_BUFFER_SIZE;
+ info.src_config.format = layer_formats[f];
+ info.dst_pos.x = ((layer_output_mode->hdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT);
+ info.dst_pos.y = ((layer_output_mode->vdisplay - TDM_UT_BUFFER_SIZE) / TDM_UT_BACKEND_TEST_CNT);
+ info.dst_pos.w = TDM_UT_BUFFER_SIZE;
+ info.dst_pos.h = TDM_UT_BUFFER_SIZE;
+ info.transform = TDM_TRANSFORM_NORMAL;
+
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, layer_output, layer, &info, buffers, TDM_UT_BACKEND_TEST_CNT, false), true);
DestroyBuffers();
TDM_UT_ASK_YNR("* Successed to move '%c%c%c%c' small size(%dx%d) frames on screen? (output: %d, layer: %d)",
- FOURCC_STR(formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, pipe, l);
+ FOURCC_STR(layer_formats[f]), TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, layer_output_pipe, l);
}
EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
}
for (int l = 0; l < layer_count; l++) {
- tdm_error ret;
- tdm_output *output;
tdm_layer *layer;
- int next_buffer = 0;
- bool done = false;
- const tbm_format *formats;
- int format_count = 0;
- const tdm_output_mode *mode = NULL;
- unsigned int flags = 0;
- unsigned int pipe = 0;
layer = layers[l];
- output = tdm_layer_get_output(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE);
+ EXPECT_EQ(PrepareLayer(layer), true);
- if (!tc_tdm_output_is_connected(output))
+ if (!tc_tdm_output_is_connected(layer_output))
continue;
if (tc_tdm_layer_is_primary_layer(layer))
continue;
if (tc_tdm_layer_is_cursor_layer(layer))
continue;
if (tc_tdm_layer_support_no_crop(layer)) {
- TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l);
+ TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", layer_output_pipe, l);
continue;
}
- TDM_UT_INFO("* testing for (output: %d, layer: %d)", pipe, l);
+ TDM_UT_INFO("* testing for (output: %d, layer: %d)", layer_output_pipe, l);
- EXPECT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE);
- EXPECT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE);
- EXPECT_NE(mode, NULL);
-
- EXPECT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
-
- EXPECT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE);
-
- for (int f = 0; f < format_count; f++) {
+ for (int f = 0; f < layer_format_count; f++) {
retry:
- TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f]));
- EXPECT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true);
+ TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(layer_formats[f]));
+ EXPECT_EQ(tc_tdm_buffer_create(layer_output_mode->hdisplay, layer_output_mode->vdisplay,
+ layer_formats[f], layer_flags | TBM_BO_SCANOUT, true, 3, buffers), true);
tdm_info_layer info;
memset(&info, 0, sizeof info);
- info.src_config.size.h = mode->hdisplay;
- info.src_config.size.v = mode->vdisplay;
- info.src_config.pos.x = mode->hdisplay / 2;
- info.src_config.pos.y = mode->vdisplay / 2;
+ info.src_config.size.h = layer_output_mode->hdisplay;
+ info.src_config.size.v = layer_output_mode->vdisplay;
+ info.src_config.pos.x = layer_output_mode->hdisplay / 2;
+ info.src_config.pos.y = layer_output_mode->vdisplay / 2;
info.src_config.pos.w = info.src_config.size.h / 2;
info.src_config.pos.h = info.src_config.size.v / 2;
- info.src_config.format = formats[f];
+ info.src_config.format = layer_formats[f];
info.dst_pos.x = info.src_config.pos.x;
info.dst_pos.y = info.src_config.pos.y;
info.dst_pos.w = info.src_config.pos.w;
info.dst_pos.h = info.src_config.pos.h;
info.transform = TDM_TRANSFORM_NORMAL;
- EXPECT_EQ(tdm_layer_set_info(layer, &info), TDM_ERROR_NONE);
- /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */
- for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) {
- tbm_surface_h displaying_buffer;
- EXPECT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE);
- done = false;
- EXPECT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE);
- while (!done)
- EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
- displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret);
- EXPECT_EQ(ret, TDM_ERROR_NONE);
- EXPECT_EQ(displaying_buffer, buffers[next_buffer]);
- next_buffer++;
- if (next_buffer == 3)
- next_buffer = 0;
- }
+ EXPECT_EQ(_tc_tdm_backend_display_layer_test(dpy, layer_output, layer, &info, buffers, TDM_UT_BACKEND_TEST_CNT, false), true);
DestroyBuffers();
TDM_UT_ASK_YNR("* Successed to crop '%c%c%c%c' frames and display it? (output: %d, layer: %d)",
- FOURCC_STR(formats[f]), pipe, l);
+ FOURCC_STR(layer_formats[f]), layer_output_pipe, l);
}
EXPECT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE);
projects / platform / core / uifw / libtdm.git / commitdiff