From 851b3c8060aa797c0439e39f14b950c1e599a440 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 27 Feb 2018 12:08:27 +0900 Subject: [PATCH 01/16] output: correct syntax error Change-Id: I2dffd741c746c9295a73e22e90b32d471a1f0315 --- src/tdm_output.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tdm_output.c b/src/tdm_output.c index e73de5b..0648b34 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -1444,7 +1444,7 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) if (*dpms_value != private_output->current_dpms_value) { tdm_value value; TDM_ERR("output(%d) dpms changed suddenly: %s -> %s", - private_output->pipe, private_output->current_dpms_value, + private_output->pipe, tdm_dpms_str(private_output->current_dpms_value), tdm_dpms_str(*dpms_value)); private_output->current_dpms_value = *dpms_value; value.u32 = *dpms_value; -- 2.7.4 From 44af6b03be92b5edae7d7f4b49a695c877c796e0 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 27 Feb 2018 14:24:40 +0900 Subject: [PATCH 02/16] fix build-break Change-Id: Ic02a14e323eee8f89e86102cd66f500fdf823772 --- include/Makefile.am | 3 ++- packaging/libtdm.spec | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/include/Makefile.am b/include/Makefile.am index ce83e6e..a16c981 100644 --- a/include/Makefile.am +++ b/include/Makefile.am @@ -7,4 +7,5 @@ libtdminclude_HEADERS = \ tdm_config.h \ tdm_log.h \ tdm_backend.h \ - tdm_helper.h + tdm_helper.h \ + tdm_deprecated.h diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 6da90ec..a489586 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -129,6 +129,7 @@ rm -f %{_unitdir_user}/basic.target.wants/tdm-socket-user.path %{_includedir}/tdm_log.h %{_includedir}/tdm_types.h %{_includedir}/tdm_config.h +%{_includedir}/tdm_deprecated.h %{_libdir}/pkgconfig/libtdm.pc %{_libdir}/libtdm.so -- 2.7.4 From b6d03eae459c5727ee489c75ccf5b99f2b86fcd4 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 27 Feb 2018 14:30:36 +0900 Subject: [PATCH 03/16] package version up to 1.15.1 Change-Id: Ic53ee701e9eec1ca90add4148ef2ab7eaf462a81 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index a489586..9ca1257 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.15.0 +Version: 1.15.1 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 7d6d085e992322f66c2610a3006f173c0acdde25 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 27 Feb 2018 15:48:21 +0900 Subject: [PATCH 04/16] rename tdm_backend to tdm_module initrd-recovery already uses 'tdm_backend' word. no other choice. Change-Id: I69acef25a284bd1a5872c6b4ee7ad5771f6a5bac --- common/tdm_log.c | 9 +- include/tdm.h | 12 +-- include/tdm_deprecated.h | 2 +- include/tdm_types.h | 2 +- src/tdm.c | 228 +++++++++++++++++++++--------------------- src/tdm_backend.c | 54 +++++----- src/tdm_capture.c | 94 ++++++++--------- src/tdm_display.c | 116 ++++++++++----------- src/tdm_event_loop.c | 44 ++++---- src/tdm_helper.c | 66 ++++++------ src/tdm_hwc_window.c | 88 ++++++++-------- src/tdm_layer.c | 66 ++++++------ src/tdm_output.c | 114 ++++++++++----------- src/tdm_pp.c | 70 ++++++------- src/tdm_private.h | 6 +- src/tdm_private_types.h | 24 ++--- utests/src/ut_tdm_display.cpp | 18 ++-- utests/src/ut_tdm_output.cpp | 12 +-- 18 files changed, 512 insertions(+), 513 deletions(-) diff --git a/common/tdm_log.c b/common/tdm_log.c index c41e869..3f6b560 100644 --- a/common/tdm_log.c +++ b/common/tdm_log.c @@ -59,7 +59,7 @@ #undef LOG_TAG #define LOG_TAG "TDM" -static unsigned int dlog_enable = 0; +static unsigned int dlog_enable = 1; static unsigned int color_enable = 1; static unsigned int assert_level = TDM_LOG_LEVEL_NONE; @@ -80,10 +80,9 @@ tdm_log_enable_color(unsigned int enable) EXTERN void tdm_log_enable_dlog(unsigned int enable) { - const char *debug = getenv("TDM_DLOG"); - if (debug) - enable = (debug[0] == '1') ? 1 : 0; - + const char *str = getenv("TDM_DLOG"); + if (str) + enable = (str[0] == '1') ? 1 : 0; dlog_enable = enable; } diff --git a/include/tdm.h b/include/tdm.h index 7d8ed4d..19d30ba 100644 --- a/include/tdm.h +++ b/include/tdm.h @@ -228,24 +228,24 @@ tdm_display_create_pp(tdm_display *dpy, tdm_error *error); /** * @brief Get the information of the TDM backend module. - * @param[in] backend A backend object + * @param[in] module A backend module object * @param[out] name The name of the TDM backend module * @param[out] vendor The vendor of the TDM backend module * @param[out] version The version of the TDM backend module * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ tdm_error -tdm_backend_get_info(tdm_backend *backend, const char **name, - const char **vendor, int *major, int *minor); +tdm_module_get_info(tdm_module *module, const char **name, + const char **vendor, int *major, int *minor); /** - * @brief Get a backend object of the given output. + * @brief Get a backend module object of the given output. * @param[in] output A output object * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. * @return A backend object if success. Otherwise, NULL. */ -tdm_backend * -tdm_output_get_backend(tdm_output *output, tdm_error *error); +tdm_module * +tdm_output_get_backend_module(tdm_output *output, tdm_error *error); /** * @brief Get the capabilities of a output object. diff --git a/include/tdm_deprecated.h b/include/tdm_deprecated.h index 06a3d24..b52eaf3 100644 --- a/include/tdm_deprecated.h +++ b/include/tdm_deprecated.h @@ -62,7 +62,7 @@ tdm_display_update(tdm_display *dpy); * @param[out] vendor The vendor of the TDM backend module * @param[out] version The version of the TDM backend module * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @see #tdm_output_get_backend, #tdm_backend_get_info + * @see #tdm_output_get_module, #tdm_module_get_info */ tdm_error tdm_display_get_backend_info(tdm_display *dpy, const char **name, diff --git a/include/tdm_types.h b/include/tdm_types.h index d5e6b18..a718f9a 100644 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -223,7 +223,7 @@ typedef void tdm_display; /** * @brief The tdm backend object */ -typedef void tdm_backend; +typedef void tdm_module; /** * @brief The tdm output object diff --git a/src/tdm.c b/src/tdm.c index be28ef5..b904755 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -64,11 +64,11 @@ _tdm_display_find_private_layer(tdm_private_output *private_output, INTERN tdm_private_output * tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { if (private_output->output_backend == output_backend) return private_output; } @@ -80,11 +80,11 @@ tdm_display_find_private_output(tdm_private_display *private_display, tdm_output INTERN void * tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { if (private_output->stamp == stamp) return private_output; } @@ -240,48 +240,48 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) static void _tdm_display_destroy_private_display(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL, *bb = NULL; + tdm_private_module *private_module = NULL, *bb = NULL; tdm_private_output *o = NULL, *oo = NULL; tdm_private_pp *p = NULL, *pp = NULL; - LIST_FOR_EACH_ENTRY_SAFE(private_backend, bb, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_backend->pp_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_module->pp_list, link) { tdm_pp_destroy_internal(p); } - LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_module->output_list, link) { _tdm_display_destroy_private_output(o); } - _tdm_display_destroy_caps_pp(&private_backend->caps_pp); - _tdm_display_destroy_caps_capture(&private_backend->caps_capture); + _tdm_display_destroy_caps_pp(&private_module->caps_pp); + _tdm_display_destroy_caps_capture(&private_module->caps_capture); - private_backend->capabilities = 0; - private_backend->caps_display.max_layer_count = 0; + private_module->capabilities = 0; + private_module->caps_display.max_layer_count = 0; - if (private_backend->outputs) { - free(private_backend->outputs); - private_backend->outputs = NULL; + if (private_module->outputs) { + free(private_module->outputs); + private_module->outputs = NULL; } } } static tdm_error -_tdm_display_update_caps_pp(tdm_private_backend *private_backend, tdm_caps_pp *caps) +_tdm_display_update_caps_pp(tdm_private_module *private_module, tdm_caps_pp *caps) { tdm_func_display *func_display; tdm_error ret; - func_display = &private_backend->func_display; + func_display = &private_module->func_display; if (!func_display->display_get_pp_capability) { - TDM_ERR("backend(%s) no display_get_pp_capability()", private_backend->module_data->name); + TDM_ERR("backend(%s) no display_get_pp_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - ret = func_display->display_get_pp_capability(private_backend->bdata, caps); + ret = func_display->display_get_pp_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) display_get_pp_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) display_get_pp_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -289,21 +289,21 @@ _tdm_display_update_caps_pp(tdm_private_backend *private_backend, tdm_caps_pp *c } static tdm_error -_tdm_display_update_caps_capture(tdm_private_backend *private_backend, tdm_caps_capture *caps) +_tdm_display_update_caps_capture(tdm_private_module *private_module, tdm_caps_capture *caps) { tdm_func_display *func_display; tdm_error ret; - func_display = &private_backend->func_display; + func_display = &private_module->func_display; if (!func_display->display_get_capture_capability) { - TDM_ERR("backend(%s) no display_get_capture_capability()", private_backend->module_data->name); + TDM_ERR("backend(%s) no display_get_capture_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - ret = func_display->display_get_capture_capability(private_backend->bdata, caps); + ret = func_display->display_get_capture_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) display_get_capture_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) display_get_capture_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -311,20 +311,20 @@ _tdm_display_update_caps_capture(tdm_private_backend *private_backend, tdm_caps_ } static tdm_error -_tdm_display_update_caps_layer(tdm_private_backend *private_backend, +_tdm_display_update_caps_layer(tdm_private_module *private_module, tdm_layer *layer_backend, tdm_caps_layer *caps) { - tdm_func_layer *func_layer = &private_backend->func_layer; + tdm_func_layer *func_layer = &private_module->func_layer; tdm_error ret; if (!func_layer->layer_get_capability) { - TDM_ERR("backend(%s) no layer_get_capability()", private_backend->module_data->name); + TDM_ERR("backend(%s) no layer_get_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } ret = func_layer->layer_get_capability(layer_backend, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) layer_get_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) layer_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -332,26 +332,26 @@ _tdm_display_update_caps_layer(tdm_private_backend *private_backend, } static tdm_error -_tdm_display_update_caps_output(tdm_private_backend *private_backend, int pipe, +_tdm_display_update_caps_output(tdm_private_module *private_module, int pipe, tdm_output *output_backend, tdm_caps_output *caps) { - tdm_func_output *func_output = &private_backend->func_output; + tdm_func_output *func_output = &private_module->func_output; char temp[TDM_NAME_LEN]; tdm_error ret; double stamp; if (!func_output->output_get_capability) { - TDM_ERR("backend(%s) no output_get_capability()", private_backend->module_data->name); + TDM_ERR("backend(%s) no output_get_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } stamp = tdm_helper_get_time(); ret = func_output->output_get_capability(output_backend, caps); TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms", - private_backend->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); + private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) output_get_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -378,7 +378,7 @@ _tdm_display_update_layer(tdm_private_output *private_output, LIST_INITHEAD(&private_layer->capture_list); private_layer->index = index; - private_layer->private_backend = private_output->private_backend; + private_layer->private_module = private_output->private_module; private_layer->private_display = private_output->private_display; private_layer->private_output = private_output; private_layer->layer_backend = layer_backend; @@ -387,35 +387,35 @@ _tdm_display_update_layer(tdm_private_output *private_output, _tdm_display_destroy_caps_layer(&private_layer->caps); - ret = _tdm_display_update_caps_layer(private_output->private_backend, layer_backend, &private_layer->caps); + ret = _tdm_display_update_caps_layer(private_output->private_module, layer_backend, &private_layer->caps); TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); return TDM_ERROR_NONE; } INTERN tdm_error -tdm_display_update_output(tdm_private_backend *private_backend, +tdm_display_update_output(tdm_private_module *private_module, tdm_output *output_backend, int pipe, unsigned int need_new_caps) { - tdm_func_output *func_output = &private_backend->func_output; + tdm_func_output *func_output = &private_module->func_output; tdm_private_output *private_output = NULL; tdm_layer **layers = NULL; int layer_count = 0, i; tdm_error ret; - private_output = tdm_display_find_private_output(private_backend->private_display, output_backend); + private_output = tdm_display_find_private_output(private_module->private_display, output_backend); if (!private_output) { private_output = calloc(1, sizeof(tdm_private_output)); TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OUT_OF_MEMORY); private_output->stamp = tdm_helper_get_time(); - while (tdm_display_find_output_stamp(private_backend->private_display, private_output->stamp)) + while (tdm_display_find_output_stamp(private_module->private_display, private_output->stamp)) private_output->stamp++; - LIST_ADDTAIL(&private_output->link, &private_backend->output_list); + LIST_ADDTAIL(&private_output->link, &private_module->output_list); - private_output->private_backend = private_backend; - private_output->private_display = private_backend->private_display; + private_output->private_module = private_module; + private_output->private_display = private_module->private_display; private_output->current_dpms_value = TDM_OUTPUT_DPMS_OFF; private_output->output_backend = output_backend; private_output->pipe = pipe; @@ -444,7 +444,7 @@ tdm_display_update_output(tdm_private_backend *private_backend, if (need_new_caps) { _tdm_display_destroy_caps_output(&private_output->caps); - ret = _tdm_display_update_caps_output(private_backend, pipe, output_backend, &private_output->caps); + ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->caps); TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); } @@ -483,9 +483,9 @@ _tdm_display_set_main_first(tdm_output **outputs, int index) } static tdm_output ** -_tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *count) +_tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) { - tdm_func_display *func_display = &private_backend->func_display; + tdm_func_display *func_display = &private_module->func_display; tdm_output **outputs = NULL; tdm_output **new_outputs = NULL; tdm_output *output_dsi = NULL; @@ -497,12 +497,12 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun tdm_error ret; /* don't change list order if not init time */ - if (private_backend->outputs) { + if (private_module->outputs) { TDM_ERR("can't change output order"); - return private_backend->outputs; + return private_module->outputs; } - outputs = func_display->display_get_outputs(private_backend->bdata, &output_count, &ret); + outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); if (ret != TDM_ERROR_NONE) goto failed_get_outputs; @@ -511,13 +511,13 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun if (output_count == 0) goto failed_get_outputs; else if (output_count == 1) { - private_backend->outputs = outputs; + private_module->outputs = outputs; return outputs; } /* count connected outputs */ for (i = 0; i < output_count; i++) { - tdm_func_output *func_output = &private_backend->func_output; + tdm_func_output *func_output = &private_module->func_output; tdm_caps_output caps; memset(&caps, 0, sizeof(tdm_caps_output)); @@ -593,7 +593,7 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun new_outputs = outputs; } - private_backend->outputs = new_outputs; + private_module->outputs = new_outputs; return new_outputs; @@ -606,34 +606,34 @@ failed_get_outputs: static tdm_error _tdm_display_update(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_error ret = TDM_ERROR_NONE; int index = 0; - if (private_display->pp_backend) { - ret = _tdm_display_update_caps_pp(private_display->pp_backend, - &private_display->pp_backend->caps_pp); + if (private_display->pp_module) { + ret = _tdm_display_update_caps_pp(private_display->pp_module, + &private_display->pp_module->caps_pp); if (ret != TDM_ERROR_NONE) goto failed_update; } - if (private_display->capture_backend) { - ret = _tdm_display_update_caps_capture(private_display->capture_backend, - &private_display->capture_backend->caps_capture); + if (private_display->capture_module) { + ret = _tdm_display_update_caps_capture(private_display->capture_module, + &private_display->capture_module->caps_capture); if (ret != TDM_ERROR_NONE) goto failed_update; } - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { tdm_output **outputs; int output_count = 0, i; - outputs = _tdm_display_get_ordered_outputs(private_backend, &output_count); + outputs = _tdm_display_get_ordered_outputs(private_module, &output_count); if (!outputs) goto failed_update; for (i = 0; i < output_count; i++) { - ret = tdm_display_update_output(private_backend, outputs[i], index++, 1); + ret = tdm_display_update_output(private_module, outputs[i], index++, 1); if (ret != TDM_ERROR_NONE) goto failed_update; } @@ -718,11 +718,11 @@ _tdm_display_check_module(tdm_backend_module *module) } static tdm_error -_tdm_display_check_backend_functions(tdm_private_backend *private_backend) +_tdm_display_check_backend_functions(tdm_private_module *private_module) { - tdm_func_display *func_display = &private_backend->func_display; - tdm_func_output *func_output = &private_backend->func_output; - tdm_func_layer *func_layer = &private_backend->func_layer; + tdm_func_display *func_display = &private_module->func_display; + tdm_func_output *func_output = &private_module->func_output; + tdm_func_layer *func_layer = &private_module->func_layer; tdm_error ret; /* below functions should be implemented in backend side */ @@ -733,14 +733,14 @@ _tdm_display_check_backend_functions(tdm_private_backend *private_backend) TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE); - ret = func_display->display_get_capability(private_backend->bdata, &private_backend->caps_display); + ret = func_display->display_get_capability(private_module->bdata, &private_module->caps_display); if (ret != TDM_ERROR_NONE) { TDM_ERR("display_get_capability() failed"); return TDM_ERROR_BAD_MODULE; } - if (private_backend->capabilities & TDM_DISPLAY_CAPABILITY_PP) { - tdm_func_pp *func_pp = &private_backend->func_pp; + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) { + tdm_func_pp *func_pp = &private_module->func_pp; TDM_RETURN_VAL_IF_FAIL(func_display->display_get_pp_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_display->display_create_pp, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_pp->pp_destroy, TDM_ERROR_BAD_MODULE); @@ -748,12 +748,12 @@ _tdm_display_check_backend_functions(tdm_private_backend *private_backend) TDM_RETURN_VAL_IF_FAIL(func_pp->pp_set_done_handler, TDM_ERROR_BAD_MODULE); } - if (private_backend->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { - tdm_func_capture *func_capture = &private_backend->func_capture; + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { + tdm_func_capture *func_capture = &private_module->func_capture; TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, TDM_ERROR_BAD_MODULE); - if (private_backend->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT) + if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT) TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE); - if (private_backend->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER) + if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER) TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_capture->capture_destroy, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_capture->capture_commit, TDM_ERROR_BAD_MODULE); @@ -771,7 +771,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, void *module = NULL; tdm_backend_module *module_data; tdm_backend_data *bdata = NULL; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_error ret; double stamp; int size; @@ -782,14 +782,14 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, return TDM_ERROR_BAD_MODULE; }; - private_backend = calloc(1, sizeof *private_backend); - if (!private_backend) { + private_module = calloc(1, sizeof *private_module); + if (!private_module) { TDM_ERR("alloc failed: %m"); ret = TDM_ERROR_OUT_OF_MEMORY; goto failed_load; } - private_backend->private_display = private_display; + private_module->private_display = private_display; stamp = tdm_helper_get_time(); @@ -802,7 +802,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, goto failed_load; } - private_backend->module = module; + private_module->module = module; module_data = dlsym(module, "tdm_backend_module_data"); if (!module_data) { @@ -813,7 +813,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, } TDM_TRACE_END(); - private_backend->module_data = module_data; + private_module->module_data = module_data; TDM_DBG("dlopen, dlsym time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); @@ -824,7 +824,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, goto failed_load; } - private_display->current_backend = private_backend; + private_display->current_module = private_module; /* We don't care if backend_data is NULL or not. It's up to backend. */ TDM_TRACE_BEGIN("TDM_Init_Backend"); @@ -833,26 +833,26 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, TDM_DBG("backend init() time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); TDM_TRACE_END(); - private_display->current_backend = NULL; + private_display->current_module = NULL; - private_backend->bdata = bdata; + private_module->bdata = bdata; if (ret != TDM_ERROR_NONE) { TDM_ERR("backend(%s) load failed: init error", module_data->name); goto failed_load; } - ret = _tdm_display_check_backend_functions(private_backend); + ret = _tdm_display_check_backend_functions(private_module); if (ret != TDM_ERROR_NONE) { TDM_ERR("backend(%s) load failed: check functions error", module_data->name); goto failed_load; } - LIST_INITHEAD(&private_backend->output_list); - LIST_INITHEAD(&private_backend->pp_list); - LIST_INITHEAD(&private_backend->capture_list); + LIST_INITHEAD(&private_module->output_list); + LIST_INITHEAD(&private_module->pp_list); + LIST_INITHEAD(&private_module->capture_list); - LIST_ADDTAIL(&private_backend->link, &private_display->backend_list); + LIST_ADDTAIL(&private_module->link, &private_display->module_list); TDM_INFO("Success to load '%s' module", module_data->name); @@ -862,8 +862,8 @@ failed_load: module_data->deinit(bdata); if (module) dlclose(module); - if (private_backend) - free(private_backend); + if (private_module) + free(private_module); return ret; } @@ -876,7 +876,7 @@ _tdm_display_load_modules(tdm_private_display *private_display) char *arg; char *end; - LIST_INITHEAD(&private_display->backend_list); + LIST_INITHEAD(&private_display->module_list); module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE); @@ -894,7 +894,7 @@ _tdm_display_load_modules(tdm_private_display *private_display) } /* load bufmgr priv from dummy lib */ - if (LIST_IS_EMPTY(&private_display->backend_list)) { + if (LIST_IS_EMPTY(&private_display->module_list)) { TDM_WRN("No backend. loading a %s backend", TDM_DUMMY_MODULE); ret = _tdm_display_load_module_with_file(private_display, TDM_DUMMY_MODULE); if (ret == TDM_ERROR_NONE) @@ -909,17 +909,17 @@ _tdm_display_load_modules(tdm_private_display *private_display) static void _tdm_display_unload_modules(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL, *bb = NULL; + tdm_private_module *private_module = NULL, *bb = NULL; - LIST_FOR_EACH_ENTRY_SAFE(private_backend, bb, &private_display->backend_list, link) { - LIST_DEL(&private_backend->link); + LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { + LIST_DEL(&private_module->link); - if (private_backend->module_data) - private_backend->module_data->deinit(private_backend->bdata); - if (private_backend->module) - dlclose(private_backend->module); + if (private_module->module_data) + private_module->module_data->deinit(private_module->bdata); + if (private_module->module) + dlclose(private_module->module); - free(private_backend); + free(private_module); } } /* LCOV_EXCL_STOP */ @@ -1047,9 +1047,9 @@ tdm_display_init(tdm_error *error) private_display->init_count = 1; g_private_display = private_display; - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; - LIST_FOR_EACH_ENTRY(b, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { if (o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) tdm_output_need_validate_event_init(o); @@ -1061,12 +1061,12 @@ tdm_display_init(tdm_error *error) * this functionality can be turned off which means a default mode */ mode = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, 0); if (mode > 0) { - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; /* outputs which support hwc capability can work only * if commit_per_vblank mode is '0' (default mode) */ - LIST_FOR_EACH_ENTRY(b, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) tdm_output_choose_commit_per_vblank_mode(o, mode); @@ -1181,13 +1181,13 @@ tdm_display_is_valid(tdm_display *dpy) INTERN int tdm_output_is_valid(tdm_output *output) { - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; if (!output || !g_private_display) return 0; - LIST_FOR_EACH_ENTRY(b, &g_private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &g_private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) if (o == output) return 1; @@ -1198,9 +1198,9 @@ tdm_output_is_valid(tdm_output *output) /* LCOV_EXCL_START */ INTERN int -tdm_backend_check_module_abi(tdm_private_backend *private_backend, int abimaj, int abimin) +tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin) { - tdm_backend_module *module = private_backend->module_data; + tdm_backend_module *module = private_module->module_data; if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj) return 0; @@ -1288,7 +1288,7 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s TDM_GOTO_IF_FAIL(path != NULL, done); if (!strncmp(arg, "current", 7)) { - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; if (!private_display) { @@ -1296,7 +1296,7 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s goto done; } - LIST_FOR_EACH_ENTRY(b, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { tdm_private_layer *l = NULL; LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) { @@ -1365,15 +1365,15 @@ INTERN tdm_error tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable) { tdm_private_display *private_display = dpy; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; const tdm_output_mode *mode = NULL; tdm_vblank *vblank = NULL; tdm_error ret = TDM_ERROR_NONE; if (!enable) { - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { if (private_output->ttrace_vblank) tdm_vblank_destroy(private_output->ttrace_vblank); private_output->ttrace_vblank = NULL; diff --git a/src/tdm_backend.c b/src/tdm_backend.c index ed57b34..d2488d3 100644 --- a/src/tdm_backend.c +++ b/src/tdm_backend.c @@ -73,14 +73,14 @@ tdm_backend_register_func_display(tdm_display *dpy, TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_INVALID_PARAMETER); - assert(private_display->current_backend); + assert(private_display->current_module); /* the ABI version of backend module should be more than 1.1 */ - module = private_display->current_backend->module_data; + module = private_display->current_module->module_data; if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - private_display->current_backend->func_display = *func_display; + private_display->current_module->func_display = *func_display; return TDM_ERROR_NONE; } @@ -96,14 +96,14 @@ tdm_backend_register_func_output(tdm_display *dpy, tdm_func_output *func_output) TDM_RETURN_VAL_IF_FAIL(func_output != NULL, TDM_ERROR_INVALID_PARAMETER); - assert(private_display->current_backend); + assert(private_display->current_module); /* the ABI version of backend module should be more than 1.1 */ - module = private_display->current_backend->module_data; + module = private_display->current_module->module_data; if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - private_display->current_backend->func_output = *func_output; + private_display->current_module->func_output = *func_output; return TDM_ERROR_NONE; } @@ -119,14 +119,14 @@ tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer) TDM_RETURN_VAL_IF_FAIL(func_layer != NULL, TDM_ERROR_INVALID_PARAMETER); - assert(private_display->current_backend); + assert(private_display->current_module); /* the ABI version of backend module should be more than 1.1 */ - module = private_display->current_backend->module_data; + module = private_display->current_module->module_data; if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - private_display->current_backend->func_layer = *func_layer; + private_display->current_module->func_layer = *func_layer; return TDM_ERROR_NONE; } @@ -142,16 +142,16 @@ tdm_backend_register_func_hwc_window(tdm_display *dpy, tdm_func_hwc_window *func TDM_RETURN_VAL_IF_FAIL(func_hwc_window != NULL, TDM_ERROR_INVALID_PARAMETER); - assert(private_display->current_backend); + assert(private_display->current_module); - module = private_display->current_backend->module_data; + module = private_display->current_module->module_data; /* FIX ME: Temporarily, we set the version of hwc window to 1.1 for the development. Originally the hwc window version is 2.0. */ if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - private_display->current_backend->func_hwc_window = *func_hwc_window; + private_display->current_module->func_hwc_window = *func_hwc_window; return TDM_ERROR_NONE; } @@ -166,15 +166,15 @@ tdm_backend_register_func_pp(tdm_display *dpy, tdm_func_pp *func_pp) if (!func_pp) return TDM_ERROR_NONE; - assert(private_display->current_backend); + assert(private_display->current_module); - private_display->current_backend->capabilities |= TDM_DISPLAY_CAPABILITY_PP; - private_display->current_backend->func_pp = *func_pp; + private_display->current_module->capabilities |= TDM_DISPLAY_CAPABILITY_PP; + private_display->current_module->func_pp = *func_pp; - if (!private_display->pp_backend) - private_display->pp_backend = private_display->current_backend; + if (!private_display->pp_module) + private_display->pp_module = private_display->current_module; else - TDM_ERR("already has pp backend(%s)", private_display->pp_backend->module_data->name); + TDM_ERR("already has pp backend(%s)", private_display->pp_module->module_data->name); return TDM_ERROR_NONE; } @@ -190,16 +190,16 @@ tdm_backend_register_func_capture(tdm_display *dpy, if (!func_capture) return TDM_ERROR_NONE; - assert(private_display->current_backend); + assert(private_display->current_module); - private_display->current_backend->capabilities |= TDM_DISPLAY_CAPABILITY_CAPTURE; - private_display->current_backend->func_capture = *func_capture; + private_display->current_module->capabilities |= TDM_DISPLAY_CAPABILITY_CAPTURE; + private_display->current_module->func_capture = *func_capture; //TODO: remove later - if (!private_display->capture_backend) - private_display->capture_backend = private_display->current_backend; + if (!private_display->capture_module) + private_display->capture_module = private_display->current_module; else - TDM_ERR("already has capture backend(%s)", private_display->capture_backend->module_data->name); + TDM_ERR("already has capture backend(%s)", private_display->capture_module->module_data->name); return TDM_ERROR_NONE; } @@ -210,10 +210,10 @@ _look_for_frontend_hwc_output(tdm_output *backend_output) { tdm_private_output *frontend_output = NULL, *o = NULL; tdm_private_display *private_display = tdm_display_get(); - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(o, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(o, &private_module->output_list, link) { if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) continue; diff --git a/src/tdm_capture.c b/src/tdm_capture.c index b7b8631..982230f 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -42,14 +42,14 @@ #define CAPTURE_FUNC_ENTRY() \ tdm_func_capture *func_capture; \ tdm_private_display *private_display; \ - tdm_private_backend *private_backend; \ + tdm_private_module *private_module; \ tdm_private_capture *private_capture; \ tdm_error ret = TDM_ERROR_NONE; \ TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \ private_capture = (tdm_private_capture*)capture; \ private_display = private_capture->private_display; \ - private_backend = private_capture->private_backend; \ - func_capture = &private_backend->func_capture + private_module = private_capture->private_module; \ + func_capture = &private_module->func_capture static void _tdm_capture_print_list(struct list_head *list) @@ -153,7 +153,7 @@ _tdm_capture_thread_cb_done(tdm_private_display *private_display, void *object, } static void -_tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *user_data) +_tdm_capture_cb_done(tdm_capture *capture_module, tbm_surface_h buffer, void *user_data) { tdm_private_capture *private_capture = user_data; tdm_thread_cb_capture_done capture_done; @@ -176,13 +176,13 @@ _tdm_capture_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *u static void * _tdm_capture_find_object(tdm_private_display *private_display, double stamp) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_capture *private_capture = NULL; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_capture, &private_backend->capture_list, display_link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_capture, &private_module->capture_list, display_link) { if (private_capture->stamp == stamp) return private_capture; } @@ -204,34 +204,34 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_error *error) { tdm_private_display *private_display = private_output->private_display; - tdm_private_backend *private_backend = private_output->private_backend; - tdm_func_output *func_output = &private_backend->func_output; - tdm_func_capture *func_capture = &private_backend->func_capture; + tdm_private_module *private_module = private_output->private_module; + tdm_func_output *func_output = &private_module->func_output; + tdm_func_capture *func_capture = &private_module->func_capture; tdm_private_capture *private_capture = NULL; - tdm_capture *capture_backend = NULL; + tdm_capture *capture_module = NULL; tdm_error ret = TDM_ERROR_NONE; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - if (!(private_backend->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { + if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { /* LCOV_EXCL_START */ - TDM_ERR("backend(%s) no capture capability", private_backend->module_data->name); + TDM_ERR("backend(%s) no capture capability", private_module->module_data->name); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; /* LCOV_EXCL_STOP */ } - if (!(private_backend->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) { + if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) { /* LCOV_EXCL_START */ - TDM_ERR("backend(%s) no output capture capability", private_backend->module_data->name); + TDM_ERR("backend(%s) no output capture capability", private_module->module_data->name); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; /* LCOV_EXCL_STOP */ } - capture_backend = func_output->output_create_capture( + capture_module = func_output->output_create_capture( private_output->output_backend, &ret); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ @@ -245,7 +245,7 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, if (!private_capture) { /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); - func_capture->capture_destroy(capture_backend); + func_capture->capture_destroy(capture_module); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; return NULL; @@ -255,18 +255,18 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, ret = tdm_thread_cb_add(private_capture, TDM_THREAD_CB_CAPTURE_DONE, NULL, _tdm_capture_thread_cb_done, NULL); if (ret != TDM_ERROR_NONE) { TDM_ERR("capture tdm_thread_cb_add failed"); - func_capture->capture_destroy(capture_backend); + func_capture->capture_destroy(capture_module); free(private_capture); if (error) *error = ret; return NULL; } - ret = func_capture->capture_set_done_handler(capture_backend, _tdm_capture_cb_done, private_capture); + ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("capture(%p) set capture_done_handler failed", private_capture); - func_capture->capture_destroy(capture_backend); + func_capture->capture_destroy(capture_module); free(private_capture); if (error) *error = ret; @@ -279,15 +279,15 @@ tdm_capture_create_output_internal(tdm_private_output *private_output, private_capture->stamp++; LIST_ADD(&private_capture->link, &private_output->capture_list); - LIST_ADD(&private_capture->display_link, &private_backend->capture_list); + LIST_ADD(&private_capture->display_link, &private_module->capture_list); - private_capture->private_backend = private_backend; + private_capture->private_module = private_module; private_capture->target = TDM_CAPTURE_TARGET_OUTPUT; private_capture->private_display = private_display; private_capture->private_output = private_output; private_capture->private_layer = NULL; - private_capture->capture_backend = capture_backend; + private_capture->capture_module = capture_module; private_capture->owner_tid = syscall(SYS_gettid); LIST_INITHEAD(&private_capture->pending_buffer_list); @@ -307,31 +307,31 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, tdm_error *error) { tdm_private_output *private_output = private_layer->private_output; - tdm_private_backend *private_backend = private_layer->private_backend; + tdm_private_module *private_module = private_layer->private_module; tdm_private_display *private_display = private_output->private_display; - tdm_func_layer *func_layer = &private_backend->func_layer; - tdm_func_capture *func_capture = &private_backend->func_capture; + tdm_func_layer *func_layer = &private_module->func_layer; + tdm_func_capture *func_capture = &private_module->func_capture; tdm_private_capture *private_capture = NULL; - tdm_capture *capture_backend = NULL; + tdm_capture *capture_module = NULL; tdm_error ret = TDM_ERROR_NONE; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - if (!(private_backend->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { - TDM_ERR("backend(%s) no capture capability", private_backend->module_data->name); + if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { + TDM_ERR("backend(%s) no capture capability", private_module->module_data->name); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; } - if (!(private_backend->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)) { - TDM_ERR("backend(%s) no layer capture capability", private_backend->module_data->name); + if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)) { + TDM_ERR("backend(%s) no layer capture capability", private_module->module_data->name); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; } - capture_backend = func_layer->layer_create_capture(private_layer->layer_backend, + capture_module = func_layer->layer_create_capture(private_layer->layer_backend, &ret); if (ret != TDM_ERROR_NONE) return NULL; @@ -339,7 +339,7 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, private_capture = calloc(1, sizeof(tdm_private_capture)); if (!private_capture) { TDM_ERR("failed: alloc memory"); - func_capture->capture_destroy(capture_backend); + func_capture->capture_destroy(capture_module); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; return NULL; @@ -350,15 +350,15 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, private_capture->stamp++; LIST_ADD(&private_capture->link, &private_layer->capture_list); - LIST_ADD(&private_capture->display_link, &private_backend->capture_list); + LIST_ADD(&private_capture->display_link, &private_module->capture_list); - private_capture->private_backend = private_backend; + private_capture->private_module = private_module; private_capture->target = TDM_CAPTURE_TARGET_LAYER; private_capture->private_display = private_display; private_capture->private_output = private_output; private_capture->private_layer = private_layer; - private_capture->capture_backend = capture_backend; + private_capture->capture_module = capture_module; private_capture->owner_tid = syscall(SYS_gettid); LIST_INITHEAD(&private_capture->pending_buffer_list); @@ -377,7 +377,7 @@ INTERN void tdm_capture_destroy_internal(tdm_private_capture *private_capture) { tdm_private_display *private_display; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_capture *func_capture; tdm_capture_private_buffer *b = NULL, *bb = NULL; struct list_head clone_list; @@ -394,9 +394,9 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture) LIST_DEL(&private_capture->link); LIST_DEL(&private_capture->display_link); - private_backend = private_capture->private_backend; - func_capture = &private_backend->func_capture; - func_capture->capture_destroy(private_capture->capture_backend); + private_module = private_capture->private_module; + func_capture = &private_module->func_capture; + func_capture->capture_destroy(private_capture->capture_module); if (!LIST_IS_EMPTY(&private_capture->pending_buffer_list)) { TDM_WRN("capture(%p) not finished:", private_capture); @@ -501,7 +501,7 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info) FOURCC_STR(info->dst_config.format), info->transform, info->type, info->frequency, info->flags); - ret = func_capture->capture_set_info(private_capture->capture_backend, info); + ret = func_capture->capture_set_info(private_capture->capture_module, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); private_capture->info = *info; @@ -554,15 +554,15 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) /* LCOV_EXCL_STOP */ } - if (tdm_backend_check_module_abi(private_backend, 1, 2) && - private_backend->caps_capture.max_attach_count > 0) { + if (tdm_module_check_abi(private_module, 1, 2) && + private_module->caps_capture.max_attach_count > 0) { /* LCOV_EXCL_START */ int length = LIST_LENGTH(&private_capture->pending_buffer_list) + LIST_LENGTH(&private_capture->buffer_list); - if (length >= private_backend->caps_capture.max_attach_count) { + if (length >= private_module->caps_capture.max_attach_count) { _pthread_mutex_unlock(&private_display->lock); TDM_DBG("failed: backend(%s) too many attached!! max_attach_count(%d)", - private_backend->module_data->name, private_backend->caps_capture.max_attach_count); + private_module->module_data->name, private_module->caps_capture.max_attach_count); return TDM_ERROR_BAD_REQUEST; } /* LCOV_EXCL_STOP */ @@ -577,7 +577,7 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) /* LCOV_EXCL_STOP */ } - ret = func_capture->capture_attach(private_capture->capture_backend, buffer); + ret = func_capture->capture_attach(private_capture->capture_module, buffer); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); if (ret != TDM_ERROR_NONE) { @@ -644,7 +644,7 @@ tdm_capture_commit(tdm_capture *capture) LIST_ADDTAIL(&b->commit_link, &commit_buffer_list); } - ret = func_capture->capture_commit(private_capture->capture_backend); + ret = func_capture->capture_commit(private_capture->capture_module); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) { diff --git a/src/tdm_display.c b/src/tdm_display.c index 81a6ff5..ff605e2 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -56,18 +56,18 @@ private_display = (tdm_private_display*)dpy; #define BACKEND_FUNC_ENTRY() \ - tdm_private_backend *private_backend; \ + tdm_private_module *private_module; \ tdm_private_display *private_display; \ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ - TDM_RETURN_VAL_IF_FAIL(backend != NULL, TDM_ERROR_INVALID_PARAMETER); \ - private_backend = (tdm_private_backend*)backend; \ - private_display = private_backend->private_display; + TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \ + private_module = (tdm_private_module*)module; \ + private_display = private_module->private_display; EXTERN tdm_error tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; DISPLAY_FUNC_ENTRY(); @@ -77,8 +77,8 @@ tdm_display_get_capabilities(tdm_display *dpy, *capabilities = 0; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - *capabilities |= private_backend->capabilities; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + *capabilities |= private_module->capabilities; } _pthread_mutex_unlock(&private_display->lock); @@ -90,7 +90,7 @@ EXTERN tdm_error tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities) { - tdm_private_backend *pp_backend; + tdm_private_module *pp_module; DISPLAY_FUNC_ENTRY(); @@ -98,7 +98,7 @@ tdm_display_get_pp_capabilities(tdm_display *dpy, _pthread_mutex_lock(&private_display->lock); - if (!private_display->pp_backend) { + if (!private_display->pp_module) { /* LCOV_EXCL_START */ TDM_ERR("no pp capability"); _pthread_mutex_unlock(&private_display->lock); @@ -106,9 +106,9 @@ tdm_display_get_pp_capabilities(tdm_display *dpy, /* LCOV_EXCL_STOP */ } - pp_backend = private_display->pp_backend; + pp_module = private_display->pp_module; - *capabilities = pp_backend->caps_pp.capabilities; + *capabilities = pp_module->caps_pp.capabilities; _pthread_mutex_unlock(&private_display->lock); @@ -119,7 +119,7 @@ EXTERN tdm_error tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **formats, int *count) { - tdm_private_backend *pp_backend; + tdm_private_module *pp_module; DISPLAY_FUNC_ENTRY(); @@ -128,7 +128,7 @@ tdm_display_get_pp_available_formats(tdm_display *dpy, _pthread_mutex_lock(&private_display->lock); - if (!private_display->pp_backend) { + if (!private_display->pp_module) { /* LCOV_EXCL_START */ TDM_ERR("no pp capability"); _pthread_mutex_unlock(&private_display->lock); @@ -136,10 +136,10 @@ tdm_display_get_pp_available_formats(tdm_display *dpy, /* LCOV_EXCL_STOP */ } - pp_backend = private_display->pp_backend; + pp_module = private_display->pp_module; - *formats = (const tbm_format *)pp_backend->caps_pp.formats; - *count = pp_backend->caps_pp.format_count; + *formats = (const tbm_format *)pp_module->caps_pp.formats; + *count = pp_module->caps_pp.format_count; _pthread_mutex_unlock(&private_display->lock); @@ -150,13 +150,13 @@ EXTERN tdm_error tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, int *max_w, int *max_h, int *preferred_align) { - tdm_private_backend *pp_backend; + tdm_private_module *pp_module; DISPLAY_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - if (!private_display->pp_backend) { + if (!private_display->pp_module) { /* LCOV_EXCL_START */ TDM_ERR("no pp capability"); _pthread_mutex_unlock(&private_display->lock); @@ -164,18 +164,18 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, /* LCOV_EXCL_STOP */ } - pp_backend = private_display->pp_backend; + pp_module = private_display->pp_module; if (min_w) - *min_w = TDM_FRONT_VALUE(pp_backend->caps_pp.min_w); + *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w); if (min_h) - *min_h = TDM_FRONT_VALUE(pp_backend->caps_pp.min_h); + *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h); if (max_w) - *max_w = TDM_FRONT_VALUE(pp_backend->caps_pp.max_w); + *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w); if (max_h) - *max_h = TDM_FRONT_VALUE(pp_backend->caps_pp.max_h); + *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h); if (preferred_align) - *preferred_align = TDM_FRONT_VALUE(pp_backend->caps_pp.preferred_align); + *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align); _pthread_mutex_unlock(&private_display->lock); @@ -186,7 +186,7 @@ EXTERN tdm_error tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities) { - tdm_private_backend *capture_backend; + tdm_private_module *capture_module; DISPLAY_FUNC_ENTRY(); @@ -194,7 +194,7 @@ tdm_display_get_capture_capabilities(tdm_display *dpy, _pthread_mutex_lock(&private_display->lock); - if (!private_display->capture_backend) { + if (!private_display->capture_module) { /* LCOV_EXCL_START */ TDM_ERR("no capture capability"); _pthread_mutex_unlock(&private_display->lock); @@ -202,9 +202,9 @@ tdm_display_get_capture_capabilities(tdm_display *dpy, /* LCOV_EXCL_STOP */ } - capture_backend = private_display->capture_backend; + capture_module = private_display->capture_module; - *capabilities = capture_backend->caps_capture.capabilities; + *capabilities = capture_module->caps_capture.capabilities; _pthread_mutex_unlock(&private_display->lock); @@ -215,7 +215,7 @@ EXTERN tdm_error tdm_display_get_capture_available_formats(tdm_display *dpy, const tbm_format **formats, int *count) { - tdm_private_backend *capture_backend; + tdm_private_module *capture_module; DISPLAY_FUNC_ENTRY(); @@ -224,7 +224,7 @@ tdm_display_get_capture_available_formats(tdm_display *dpy, _pthread_mutex_lock(&private_display->lock); - if (!private_display->capture_backend) { + if (!private_display->capture_module) { /* LCOV_EXCL_START */ TDM_ERR("no capture capability"); _pthread_mutex_unlock(&private_display->lock); @@ -232,10 +232,10 @@ tdm_display_get_capture_available_formats(tdm_display *dpy, /* LCOV_EXCL_STOP */ } - capture_backend = private_display->capture_backend; + capture_module = private_display->capture_module; - *formats = (const tbm_format *)capture_backend->caps_capture.formats; - *count = capture_backend->caps_capture.format_count; + *formats = (const tbm_format *)capture_module->caps_capture.formats; + *count = capture_module->caps_capture.format_count; _pthread_mutex_unlock(&private_display->lock); @@ -246,13 +246,13 @@ EXTERN tdm_error tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h, int *max_w, int *max_h, int *preferred_align) { - tdm_private_backend *capture_backend; + tdm_private_module *capture_module; DISPLAY_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - if (!private_display->capture_backend) { + if (!private_display->capture_module) { /* LCOV_EXCL_START */ TDM_ERR("no capture capability"); _pthread_mutex_unlock(&private_display->lock); @@ -260,18 +260,18 @@ tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h, /* LCOV_EXCL_STOP */ } - capture_backend = private_display->capture_backend; + capture_module = private_display->capture_module; if (min_w) - *min_w = TDM_FRONT_VALUE(capture_backend->caps_capture.min_w); + *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w); if (min_h) - *min_h = TDM_FRONT_VALUE(capture_backend->caps_capture.min_h); + *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h); if (max_w) - *max_w = TDM_FRONT_VALUE(capture_backend->caps_capture.max_w); + *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w); if (max_h) - *max_h = TDM_FRONT_VALUE(capture_backend->caps_capture.max_h); + *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h); if (preferred_align) - *preferred_align = TDM_FRONT_VALUE(capture_backend->caps_capture.preferred_align); + *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align); _pthread_mutex_unlock(&private_display->lock); @@ -294,7 +294,7 @@ tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count) EXTERN tdm_error tdm_display_get_output_count(tdm_display *dpy, int *count) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; DISPLAY_FUNC_ENTRY(); @@ -304,8 +304,8 @@ tdm_display_get_output_count(tdm_display *dpy, int *count) _pthread_mutex_lock(&private_display->lock); *count = 0; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { (*count)++; } } @@ -319,7 +319,7 @@ tdm_display_get_output_count(tdm_display *dpy, int *count) EXTERN tdm_output * tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; DISPLAY_FUNC_ENTRY_ERROR(); @@ -329,8 +329,8 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) if (error) *error = TDM_ERROR_NONE; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { if (private_output->index == index) { _pthread_mutex_unlock(&private_display->lock); return private_output; @@ -346,7 +346,7 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) EXTERN tdm_output * tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; DISPLAY_FUNC_ENTRY_ERROR(); @@ -360,8 +360,8 @@ tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error) if (error) *error = TDM_ERROR_NONE; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { if (strncmp(private_output->caps.model, name, TDM_NAME_LEN)) continue; _pthread_mutex_unlock(&private_display->lock); @@ -454,18 +454,18 @@ EXTERN tdm_error tdm_display_get_backend_info(tdm_display *dpy, const char **name, const char **vendor, int *major, int *minor) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_backend_module *module_data = NULL; DISPLAY_FUNC_ENTRY(); - TDM_DEPRECATED("Use tdm_backend_get_info"); + TDM_DEPRECATED("Use tdm_module_get_info"); _pthread_mutex_lock(&private_display->lock); /* use first backend */ - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - module_data = private_backend->module_data; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + module_data = private_module->module_data; break; } @@ -486,8 +486,8 @@ tdm_display_get_backend_info(tdm_display *dpy, const char **name, } EXTERN tdm_error -tdm_backend_get_info(tdm_backend *backend, const char **name, - const char **vendor, int *major, int *minor) +tdm_module_get_info(tdm_module *module, const char **name, + const char **vendor, int *major, int *minor) { tdm_backend_module *module_data; @@ -495,7 +495,7 @@ tdm_backend_get_info(tdm_backend *backend, const char **name, _pthread_mutex_lock(&private_display->lock); - module_data = private_backend->module_data; + module_data = private_module->module_data; if (name) *name = module_data->name; @@ -520,7 +520,7 @@ tdm_display_create_pp(tdm_display *dpy, tdm_error *error) _pthread_mutex_lock(&private_display->lock); - pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_backend, error); + pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error); _pthread_mutex_unlock(&private_display->lock); diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c index 157c8e8..32b7674 100644 --- a/src/tdm_event_loop.c +++ b/src/tdm_event_loop.c @@ -60,21 +60,21 @@ typedef struct _tdm_event_loop_source_timer { static tdm_error _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_data) { - tdm_private_backend *private_backend = (tdm_private_backend*)user_data; + tdm_private_module *private_module = (tdm_private_module*)user_data; tdm_func_display *func_display; tdm_error ret; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); - TDM_RETURN_VAL_IF_FAIL(private_backend != NULL, TDM_ERROR_OPERATION_FAILED); + TDM_RETURN_VAL_IF_FAIL(private_module != NULL, TDM_ERROR_OPERATION_FAILED); if (tdm_debug_module & TDM_DEBUG_EVENT) - TDM_INFO("backend fd(%d) event happens", private_backend->fd); + TDM_INFO("backend fd(%d) event happens", private_module->fd); - func_display = &private_backend->func_display; + func_display = &private_module->func_display; if (!func_display->display_handle_events) return TDM_ERROR_NONE; - ret = func_display->display_handle_events(private_backend->bdata); + ret = func_display->display_handle_events(private_module->bdata); return ret; } @@ -132,7 +132,7 @@ tdm_event_loop_init(tdm_private_display *private_display) INTERN void tdm_event_loop_deinit(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); @@ -144,11 +144,11 @@ tdm_event_loop_deinit(tdm_private_display *private_display) tdm_server_deinit(private_display->private_loop); - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - if (private_backend->event_source) - tdm_event_loop_source_remove(private_backend->event_source); - private_backend->event_source = NULL; - private_backend->fd = -1; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + if (private_module->event_source) + tdm_event_loop_source_remove(private_module->event_source); + private_module->event_source = NULL; + private_module->fd = -1; } if (private_display->private_loop->wl_display) @@ -171,41 +171,41 @@ INTERN void tdm_event_loop_create_backend_source(tdm_private_display *private_display) { tdm_private_loop *private_loop = private_display->private_loop; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_error ret; int fd = -1; TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); TDM_RETURN_IF_FAIL(private_loop != NULL); - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - tdm_func_display *func_display = &private_backend->func_display; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + tdm_func_display *func_display = &private_module->func_display; if (!func_display->display_get_fd) { TDM_INFO("TDM backend module won't offer a display fd"); - private_backend->event_source = NULL; - private_backend->fd = -1; + private_module->event_source = NULL; + private_module->fd = -1; continue; } - ret = func_display->display_get_fd(private_backend->bdata, &fd); + ret = func_display->display_get_fd(private_module->bdata, &fd); assert(ret == TDM_ERROR_NONE && fd >= 0); assert(func_display->display_handle_events); - private_backend->event_source = + private_module->event_source = tdm_event_loop_add_fd_handler(private_display, fd, TDM_EVENT_LOOP_READABLE, _tdm_event_loop_main_fd_handler, - private_backend, &ret); - if (!private_backend->event_source) { + private_module, &ret); + if (!private_module->event_source) { TDM_ERR("no backend fd(%d) source", fd); return; } - private_backend->fd = fd; + private_module->fd = fd; - TDM_INFO("backend fd(%d) source created", private_backend->fd); + TDM_INFO("backend fd(%d) source created", private_module->fd); } } diff --git a/src/tdm_helper.c b/src/tdm_helper.c index 0f6cd37..c7e0983 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -754,7 +754,7 @@ tdm_helper_capture_output(tdm_output *output, tbm_surface_h dst_buffer, } static char * -_tdm_helper_get_backend_information(tdm_private_backend *private_backend, char *reply, int *len) +_tdm_helper_get_backend_information(tdm_private_module *private_module, char *reply, int *len) { tdm_backend_module *module_data; tdm_func_output *func_output; @@ -766,11 +766,11 @@ _tdm_helper_get_backend_information(tdm_private_backend *private_backend, char * tdm_error ret; int i; - func_output = &private_backend->func_output; - func_layer = &private_backend->func_layer; + func_output = &private_module->func_output; + func_layer = &private_module->func_layer; /* module information */ - module_data = private_backend->module_data; + module_data = private_module->module_data; TDM_SNPRINTF(reply, len, "['%s' backend information]\n", module_data->name); TDM_SNPRINTF(reply, len, "vendor: %s\n", module_data->vendor); TDM_SNPRINTF(reply, len, "version: %d.%d\n\n", @@ -782,7 +782,7 @@ _tdm_helper_get_backend_information(tdm_private_backend *private_backend, char * TDM_SNPRINTF(reply, len, "--------------------------------------------------------------------------------------------\n"); TDM_SNPRINTF(reply, len, "idx maker model name type status dpms subpixel align_w min max phy(mm)\n"); TDM_SNPRINTF(reply, len, "--------------------------------------------------------------------------------------------\n"); - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { TDM_SNPRINTF(reply, len, "%d %s %s %s %s %s %s %u %d %dx%d %dx%d %ux%u\n", private_output->index, private_output->caps.maker, private_output->caps.model, private_output->caps.name, @@ -866,7 +866,7 @@ _tdm_helper_get_backend_information(tdm_private_backend *private_backend, char * TDM_SNPRINTF(reply, len, "-----------------------------------------------------------------------\n"); TDM_SNPRINTF(reply, len, "idx output zpos buf format size crop geometry transform\n"); TDM_SNPRINTF(reply, len, "-----------------------------------------------------------------------\n"); - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) { if (!private_layer->usable) { tdm_info_layer info; @@ -963,31 +963,31 @@ _tdm_helper_get_backend_information(tdm_private_backend *private_backend, char * } TDM_SNPRINTF(reply, len, "\n"); - if (private_backend->capabilities & TDM_DISPLAY_CAPABILITY_PP) { + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) { const char *sep = ""; TDM_SNPRINTF(reply, len, "['%s' backend PP information]\n", module_data->name); TDM_SNPRINTF(reply, len, "caps\t: "); - tdm_pp_caps_str(private_backend->caps_pp.capabilities, &reply, len); + tdm_pp_caps_str(private_module->caps_pp.capabilities, &reply, len); TDM_SNPRINTF(reply, len, "\n"); TDM_SNPRINTF(reply, len, "formats\t: "); - for (i = 0; i < private_backend->caps_pp.format_count; i++) { - if (private_backend->caps_pp.formats[i] == 0) + for (i = 0; i < private_module->caps_pp.format_count; i++) { + if (private_module->caps_pp.formats[i] == 0) continue; - TDM_SNPRINTF(reply, len, "%s%c%c%c%c", sep, FOURCC_STR(private_backend->caps_pp.formats[i])); + TDM_SNPRINTF(reply, len, "%s%c%c%c%c", sep, FOURCC_STR(private_module->caps_pp.formats[i])); sep = ","; } TDM_SNPRINTF(reply, len, "\n"); TDM_SNPRINTF(reply, len, "size\t: min(%dx%d) max(%dx%d) align_w(%d)\n", - TDM_FRONT_VALUE(private_backend->caps_pp.min_w), - TDM_FRONT_VALUE(private_backend->caps_pp.min_h), - TDM_FRONT_VALUE(private_backend->caps_pp.max_w), - TDM_FRONT_VALUE(private_backend->caps_pp.max_h), - TDM_FRONT_VALUE(private_backend->caps_pp.preferred_align)); - if (!LIST_IS_EMPTY(&private_backend->pp_list)) { + TDM_FRONT_VALUE(private_module->caps_pp.min_w), + TDM_FRONT_VALUE(private_module->caps_pp.min_h), + TDM_FRONT_VALUE(private_module->caps_pp.max_w), + TDM_FRONT_VALUE(private_module->caps_pp.max_h), + TDM_FRONT_VALUE(private_module->caps_pp.preferred_align)); + if (!LIST_IS_EMPTY(&private_module->pp_list)) { TDM_SNPRINTF(reply, len, "-------------------------------------------------------------\n"); TDM_SNPRINTF(reply, len, "src(format size crop) | dst(format size crop) | transform\n"); TDM_SNPRINTF(reply, len, "-------------------------------------------------------------\n"); - LIST_FOR_EACH_ENTRY(private_pp, &private_backend->pp_list, link) { + LIST_FOR_EACH_ENTRY(private_pp, &private_module->pp_list, link) { TDM_SNPRINTF(reply, len, "%c%c%c%c %ux%u %ux%u+%u+%u | %c%c%c%c %ux%u %ux%u+%u+%u | %s\n", FOURCC_STR(private_pp->info.src_config.format), private_pp->info.src_config.size.h, @@ -1007,31 +1007,31 @@ _tdm_helper_get_backend_information(tdm_private_backend *private_backend, char * } TDM_SNPRINTF(reply, len, "\n"); - if (private_backend->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { const char *sep = ""; TDM_SNPRINTF(reply, len, "['%s' backend capture information]\n", module_data->name); TDM_SNPRINTF(reply, len, "caps\t: "); - tdm_capture_caps_str(private_backend->caps_capture.capabilities, &reply, len); + tdm_capture_caps_str(private_module->caps_capture.capabilities, &reply, len); TDM_SNPRINTF(reply, len, "\n"); TDM_SNPRINTF(reply, len, "formats\t: "); - for (i = 0; i < private_backend->caps_capture.format_count; i++) { - if (private_backend->caps_capture.formats[i] == 0) + for (i = 0; i < private_module->caps_capture.format_count; i++) { + if (private_module->caps_capture.formats[i] == 0) continue; - TDM_SNPRINTF(reply, len, "%s%c%c%c%c", sep, FOURCC_STR(private_backend->caps_capture.formats[i])); + TDM_SNPRINTF(reply, len, "%s%c%c%c%c", sep, FOURCC_STR(private_module->caps_capture.formats[i])); sep = ","; } TDM_SNPRINTF(reply, len, "\n"); TDM_SNPRINTF(reply, len, "size\t: min(%dx%d) max(%dx%d) align_w(%d)\n", - TDM_FRONT_VALUE(private_backend->caps_capture.min_w), - TDM_FRONT_VALUE(private_backend->caps_capture.min_h), - TDM_FRONT_VALUE(private_backend->caps_capture.max_w), - TDM_FRONT_VALUE(private_backend->caps_capture.max_h), - TDM_FRONT_VALUE(private_backend->caps_capture.preferred_align)); - if (!LIST_IS_EMPTY(&private_backend->capture_list)) { + TDM_FRONT_VALUE(private_module->caps_capture.min_w), + TDM_FRONT_VALUE(private_module->caps_capture.min_h), + TDM_FRONT_VALUE(private_module->caps_capture.max_w), + TDM_FRONT_VALUE(private_module->caps_capture.max_h), + TDM_FRONT_VALUE(private_module->caps_capture.preferred_align)); + if (!LIST_IS_EMPTY(&private_module->capture_list)) { TDM_SNPRINTF(reply, len, "-----------------------------------\n"); TDM_SNPRINTF(reply, len, "dst(format size crop) | transform\n"); TDM_SNPRINTF(reply, len, "-----------------------------------\n"); - LIST_FOR_EACH_ENTRY(private_capture, &private_backend->capture_list, link) { + LIST_FOR_EACH_ENTRY(private_capture, &private_module->capture_list, link) { TDM_SNPRINTF(reply, len, "%c%c%c%c %ux%u %ux%u+%u+%u | %s\n", FOURCC_STR(private_capture->info.dst_config.format), private_capture->info.dst_config.size.h, @@ -1052,7 +1052,7 @@ EXTERN void tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len) { tdm_private_display *private_display; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; TDM_DBG_RETURN_IF_FAIL(dpy != NULL); @@ -1060,8 +1060,8 @@ tdm_helper_get_display_information(tdm_display *dpy, char *reply, int *len) _pthread_mutex_lock(&private_display->lock); - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - reply = _tdm_helper_get_backend_information(private_backend, reply, len); + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + reply = _tdm_helper_get_backend_information(private_module, reply, len); } _pthread_mutex_unlock(&private_display->lock); diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 362c798..97169e1 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -74,7 +74,7 @@ tbm_surface_queue_h tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; tbm_surface_queue_h queue = NULL; @@ -82,8 +82,8 @@ tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_get_tbm_buffer_queue) { /* LCOV_EXCL_START */ @@ -106,7 +106,7 @@ EXTERN tdm_error tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, tdm_hwc_window_composition composition_type) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); @@ -115,8 +115,8 @@ tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_set_composition_type) { /* LCOV_EXCL_START */ @@ -136,7 +136,7 @@ tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, EXTERN tdm_error tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region damage) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); @@ -145,8 +145,8 @@ tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region dama _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_set_buffer_damage) { /* LCOV_EXCL_START */ @@ -167,7 +167,7 @@ tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region dama EXTERN tdm_error tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; char fmtstr[128]; @@ -177,8 +177,8 @@ tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info) _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_set_info) { /* LCOV_EXCL_START */ @@ -212,7 +212,7 @@ tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info) EXTERN tdm_error tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window; HWC_WINDOW_FUNC_ENTRY(); @@ -228,8 +228,8 @@ tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer) /* LCOV_EXCL_STOP */ } - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_set_buffer) { /* LCOV_EXCL_START */ @@ -249,15 +249,15 @@ tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer) EXTERN tdm_error tdm_hwc_window_unset_buffer(tdm_hwc_window *hwc_window) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window; HWC_WINDOW_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_unset_buffer) { /* LCOV_EXCL_START */ @@ -279,8 +279,8 @@ tdm_hwc_window_create_internal(tdm_private_output *private_output, int is_video, tdm_error *error) { tdm_private_display *private_display = private_output->private_display; - tdm_private_backend *private_backend = private_output->private_backend; - tdm_func_output *func_output = &private_backend->func_output; + tdm_private_module *private_module = private_output->private_module; + tdm_func_output *func_output = &private_module->func_output; tdm_private_hwc_window *private_hwc_window = NULL; tdm_hwc_window *hwc_window_backend = NULL; tdm_error ret = TDM_ERROR_NONE; @@ -350,7 +350,7 @@ INTERN tdm_error tdm_hwc_window_destroy_internal(tdm_private_hwc_window * private_hwc_window) { tdm_private_output *private_output; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); @@ -359,11 +359,11 @@ tdm_hwc_window_destroy_internal(tdm_private_hwc_window * private_hwc_window) return TDM_ERROR_OPERATION_FAILED; private_output = private_hwc_window->private_output; - private_backend = private_output->private_backend; + private_module = private_output->private_module; LIST_DEL(&private_hwc_window->link); - func_output = &private_backend->func_output; + func_output = &private_module->func_output; func_output->output_hwc_destroy_window(private_output->output_backend, private_hwc_window->hwc_window_backend); free(private_hwc_window); @@ -373,15 +373,15 @@ tdm_hwc_window_destroy_internal(tdm_private_hwc_window * private_hwc_window) EXTERN tdm_error tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_set_flags) { /* LCOV_EXCL_START */ @@ -401,15 +401,15 @@ tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags) EXTERN tdm_error tdm_hwc_window_unset_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_unset_flags) { /* LCOV_EXCL_START */ @@ -444,7 +444,7 @@ _tdm_hwc_window_layer_commit_handler(tdm_layer *layer, unsigned int sequence, tdm_error tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler func, void *user_data) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; tdm_private_hwc_window_commit_handler *hwc_window_commit_handler; tdm_layer *layer = NULL; @@ -457,8 +457,8 @@ tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_get_layer) { /* LCOV_EXCL_START */ @@ -541,7 +541,7 @@ EXTERN tdm_error tdm_hwc_window_video_get_capability(tdm_hwc_window *hwc_window, tdm_hwc_window_video_capability *video_capability) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); @@ -550,8 +550,8 @@ tdm_hwc_window_video_get_capability(tdm_hwc_window *hwc_window, _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_video_get_capability) { /* LCOV_EXCL_START */ @@ -573,7 +573,7 @@ EXTERN tdm_error tdm_hwc_window_video_get_available_properties(tdm_hwc_window *hwc_window, const tdm_prop **props, int *count) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); @@ -583,8 +583,8 @@ tdm_hwc_window_video_get_available_properties(tdm_hwc_window *hwc_window, _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_video_get_available_properties) { /* LCOV_EXCL_START */ @@ -606,7 +606,7 @@ EXTERN tdm_error tdm_hwc_window_video_get_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_value *value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); @@ -615,8 +615,8 @@ tdm_hwc_window_video_get_property(tdm_hwc_window *hwc_window, _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_video_get_property) { /* LCOV_EXCL_START */ @@ -638,15 +638,15 @@ EXTERN tdm_error tdm_hwc_window_video_set_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_value value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; HWC_WINDOW_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_hwc_window = &private_backend->func_hwc_window; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; if (!func_hwc_window->hwc_window_video_set_property) { /* LCOV_EXCL_START */ diff --git a/src/tdm_layer.c b/src/tdm_layer.c index be4467e..f37a948 100644 --- a/src/tdm_layer.c +++ b/src/tdm_layer.c @@ -170,14 +170,14 @@ tdm_layer_get_zpos(tdm_layer *layer, int *zpos) EXTERN tdm_error tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (private_layer->usable) TDM_INFO("layer(%d) not usable", private_layer->index); @@ -202,7 +202,7 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value) EXTERN tdm_error tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); @@ -210,8 +210,8 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value) _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (!func_layer->layer_get_property) { /* LCOV_EXCL_START */ @@ -231,12 +231,12 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value) INTERN tdm_error tdm_layer_set_info_internal(tdm_private_layer *private_layer, tdm_info_layer *info) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; char fmtstr[128]; - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (private_layer->usable) TDM_INFO("layer(%p) not usable", private_layer); @@ -289,7 +289,7 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info) EXTERN tdm_error tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); @@ -297,8 +297,8 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info) _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (!func_layer->layer_get_info) { /* LCOV_EXCL_START */ @@ -443,7 +443,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) INTERN tdm_error tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h buffer) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_private_output *private_output = private_layer->private_output; tdm_func_layer *func_layer; @@ -462,8 +462,8 @@ tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h bu } /* LCOV_EXCL_STOP */ - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (private_layer->usable) TDM_INFO("layer(%p) not usable", private_layer); @@ -527,12 +527,12 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) INTERN tdm_error tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; tdm_error ret = TDM_ERROR_NONE; - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; _tdm_layer_free_all_buffers(private_layer); @@ -847,12 +847,12 @@ _tdm_layer_reset_pending_data(tdm_private_layer *private_layer) INTERN tdm_error tdm_layer_commit_pending_data(tdm_private_layer *private_layer) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; tdm_error ret = TDM_ERROR_NONE; - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (private_layer->pending_info_changed) { ret = func_layer->layer_set_info(private_layer->layer_backend, &private_layer->pending_info); @@ -1129,15 +1129,15 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) { TDM_RETURN_IF_FAIL(data != NULL); tdm_layer *layer = data; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; tbm_surface_h buffer = NULL; LAYER_FUNC_ENTRY_VOID_RETURN(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (!func_layer->layer_set_buffer) { /* LCOV_EXCL_START */ @@ -1193,7 +1193,7 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data) EXTERN tdm_error tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); @@ -1201,8 +1201,8 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (private_layer->usable) TDM_INFO("layer(%p) not usable", private_layer); @@ -1268,14 +1268,14 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable) EXTERN tdm_error tdm_layer_set_video_pos(tdm_layer *layer, int zpos) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) { TDM_ERR("layer(%p) is not video layer", private_layer); @@ -1317,15 +1317,15 @@ tdm_layer_create_capture(tdm_layer *layer, tdm_error *error) EXTERN tdm_error tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); TDM_RETURN_VAL_IF_FAIL(flags != NULL, TDM_ERROR_INVALID_PARAMETER); _pthread_mutex_lock(&private_display->lock); - private_backend = private_layer->private_backend; - func_layer = &private_backend->func_layer; + private_module = private_layer->private_module; + func_layer = &private_module->func_layer; if (!func_layer->layer_get_buffer_flags) { /* LCOV_EXCL_START */ diff --git a/src/tdm_output.c b/src/tdm_output.c index 0648b34..f208dfe 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -151,23 +151,23 @@ tdm_output_init(tdm_private_display *private_display) return TDM_ERROR_NONE; } -EXTERN tdm_backend * -tdm_output_get_backend(tdm_output *output, tdm_error *error) +EXTERN tdm_module * +tdm_output_get_backend_module(tdm_output *output, tdm_error *error) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; OUTPUT_FUNC_ENTRY_ERROR(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; + private_module = private_output->private_module; if (error) *error = TDM_ERROR_NONE; _pthread_mutex_unlock(&private_display->lock); - return private_backend; + return private_module; } EXTERN tdm_error @@ -272,7 +272,7 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) || (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) { - ret = tdm_display_update_output(private_output->private_backend, output_backend, private_output->pipe, 1); + ret = tdm_display_update_output(private_output->private_module, output_backend, private_output->pipe, 1); TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); } else { private_output->caps.status = status; @@ -538,7 +538,7 @@ tdm_output_get_cursor_available_size(tdm_output *output, int *min_w, int *min_h, _pthread_mutex_lock(&private_display->lock); - if (!tdm_backend_check_module_abi(private_output->private_backend, 1, 5)) { + if (!tdm_module_check_abi(private_output->private_module, 1, 5)) { _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_BAD_REQUEST; } @@ -632,14 +632,14 @@ tdm_output_get_primary_index(tdm_output *output, int *index) EXTERN tdm_error tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_set_property) { /* LCOV_EXCL_START */ @@ -660,7 +660,7 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) EXTERN tdm_error tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); @@ -668,8 +668,8 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_get_property) { /* LCOV_EXCL_START */ @@ -855,15 +855,15 @@ _tdm_output_wait_vblank(tdm_private_output *private_output, int interval, int sy tdm_output_vblank_handler func, void *user_data, unsigned int add_front) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; tdm_private_output_vblank_handler *vblank_handler = NULL, *v = NULL; unsigned int skip_request = 0; pid_t tid = syscall(SYS_gettid); tdm_error ret = TDM_ERROR_NONE; - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; /* interval SHOULD be at least 1 */ if (interval <= 0) @@ -1060,7 +1060,7 @@ INTERN tdm_error tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data) { tdm_private_output *private_output; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; tdm_private_output_commit_handler *output_commit_handler = NULL; tdm_private_layer *private_layer = NULL; @@ -1070,8 +1070,8 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl TDM_RETURN_VAL_IF_FAIL(tdm_output_is_valid(output), TDM_ERROR_INVALID_PARAMETER); private_output = (tdm_private_output*)output; - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_commit) { /* LCOV_EXCL_START */ @@ -1205,7 +1205,7 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, EXTERN tdm_error tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); @@ -1213,8 +1213,8 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_set_mode) { /* LCOV_EXCL_START */ @@ -1255,7 +1255,7 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode) EXTERN tdm_error tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); @@ -1280,8 +1280,8 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; TDM_INFO("output(%d) dpms '%s'", private_output->pipe, tdm_dpms_str(dpms_value)); @@ -1322,7 +1322,7 @@ done: EXTERN tdm_error tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); @@ -1352,8 +1352,8 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value) return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_set_dpms_handler) { TDM_WRN("not implemented: output_set_dpms_handler"); _pthread_mutex_unlock(&private_display->lock); @@ -1403,7 +1403,7 @@ INTERN tdm_error tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) { tdm_private_output *private_output; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; tdm_error ret = TDM_ERROR_NONE; @@ -1421,8 +1421,8 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value) return TDM_ERROR_NONE; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_get_dpms) { /* LCOV_EXCL_START */ @@ -1554,7 +1554,7 @@ EXTERN tdm_error tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds, uint32_t num_wnds, uint32_t *num_types) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; tdm_private_hwc_window **composited_wnds_frontend = NULL; tdm_hwc_window **composited_wnds_backend = NULL; @@ -1572,8 +1572,8 @@ tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds, return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_validate) { /* LCOV_EXCL_START */ @@ -1649,7 +1649,7 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output, tdm_hwc_window **hwc_window, tdm_hwc_window_composition *composition_types) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; tdm_private_hwc_window * private_hwc_window = NULL; int i = 0; @@ -1666,8 +1666,8 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output, return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_get_changed_composition_types) { /* LCOV_EXCL_START */ @@ -1716,7 +1716,7 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output, tdm_error tdm_output_hwc_accept_changes(tdm_output *output) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; OUTPUT_FUNC_ENTRY(); @@ -1729,8 +1729,8 @@ tdm_output_hwc_accept_changes(tdm_output *output) return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_validate) { /* LCOV_EXCL_START */ @@ -1750,7 +1750,7 @@ tdm_output_hwc_accept_changes(tdm_output *output) tbm_surface_queue_h tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; tbm_surface_queue_h queue = NULL; @@ -1766,8 +1766,8 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) return NULL; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_get_target_buffer_queue) { /* LCOV_EXCL_START */ @@ -1787,7 +1787,7 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) EXTERN tdm_error tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; OUTPUT_FUNC_ENTRY(); @@ -1810,8 +1810,8 @@ tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target /* LCOV_EXCL_STOP */ } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_set_client_target_buffer) { /* LCOV_EXCL_START */ @@ -1831,7 +1831,7 @@ tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target EXTERN tdm_error tdm_output_hwc_unset_client_target_buffer(tdm_output *output) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output = NULL; OUTPUT_FUNC_ENTRY(); @@ -1844,8 +1844,8 @@ tdm_output_hwc_unset_client_target_buffer(tdm_output *output) return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_unset_client_target_buffer) { /* LCOV_EXCL_START */ @@ -1880,7 +1880,7 @@ _tdm_output_hwc_layer_commit_handler(tdm_layer *layer, unsigned int sequence, tdm_error tdm_output_hwc_commit_client_target_buffer(tdm_output *output, tdm_output_hwc_target_buffer_commit_handler func, void *user_data) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; tdm_private_output_hwc_target_buffer_commit_handler *output_hwc_target_buffer_commit_handler; tdm_layer *layer = NULL; @@ -1898,8 +1898,8 @@ tdm_output_hwc_commit_client_target_buffer(tdm_output *output, tdm_output_hwc_ta return TDM_ERROR_BAD_REQUEST; } - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_get_client_target_buffer_layer) { /* LCOV_EXCL_START */ @@ -2001,7 +2001,7 @@ tdm_error tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format **formats, int *count) { - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); @@ -2010,8 +2010,8 @@ tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format _pthread_mutex_lock(&private_display->lock); - private_backend = private_output->private_backend; - func_output = &private_backend->func_output; + private_module = private_output->private_module; + func_output = &private_module->func_output; if (!func_output->output_hwc_get_video_supported_formats) { /* LCOV_EXCL_START */ @@ -2032,10 +2032,10 @@ tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format static int _is_hwc_output_still_existed(tdm_private_output *private_output) { - tdm_private_backend *private_backend = private_output->private_backend; + tdm_private_module *private_module = private_output->private_module; tdm_private_output *o = NULL; - LIST_FOR_EACH_ENTRY(o, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY(o, &private_module->output_list, link) { if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) continue; diff --git a/src/tdm_pp.c b/src/tdm_pp.c index cdc0bde..d9fcc31 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -40,7 +40,7 @@ #include "tdm_private.h" #define PP_FUNC_ENTRY() \ - tdm_private_backend *private_backend; \ + tdm_private_module *private_module; \ tdm_func_pp *func_pp; \ tdm_private_display *private_display; \ tdm_private_pp *private_pp; \ @@ -48,8 +48,8 @@ TDM_RETURN_VAL_IF_FAIL(pp != NULL, TDM_ERROR_INVALID_PARAMETER); \ private_pp = (tdm_private_pp*)pp; \ private_display = private_pp->private_display; \ - private_backend = private_pp->private_backend; \ - func_pp = &private_backend->func_pp + private_module = private_pp->private_module; \ + func_pp = &private_module->func_pp static void _tdm_pp_print_list(struct list_head *list) @@ -156,7 +156,7 @@ _tdm_pp_thread_cb_done(tdm_private_display *private_display, void *object, tdm_t } static void -_tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, void *user_data) +_tdm_pp_cb_done(tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *user_data) { tdm_thread_cb_pp_done pp_done; tdm_private_pp *private_pp = user_data; @@ -180,13 +180,13 @@ _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, void * static void * _tdm_pp_find_object(tdm_private_display *private_display, double stamp) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_pp *private_pp = NULL; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_pp, &private_backend->pp_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_pp, &private_module->pp_list, link) { if (private_pp->stamp == stamp) return private_pp; } @@ -204,32 +204,32 @@ tdm_pp_init(tdm_private_display *private_display) } INTERN tdm_private_pp * -tdm_pp_create_internal(tdm_private_backend *private_backend, tdm_error *error) +tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error) { tdm_private_display *private_display; tdm_func_display *func_display; tdm_func_pp *func_pp; tdm_private_pp *private_pp = NULL; - tdm_pp *pp_backend = NULL; + tdm_pp *pp_module = NULL; tdm_error ret = TDM_ERROR_NONE; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - TDM_RETURN_VAL_IF_FAIL(private_backend != NULL, NULL); + TDM_RETURN_VAL_IF_FAIL(private_module != NULL, NULL); - private_display = private_backend->private_display; - func_display = &private_backend->func_display; - func_pp = &private_backend->func_pp; + private_display = private_module->private_display; + func_display = &private_module->func_display; + func_pp = &private_module->func_pp; - if (!(private_backend->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { + if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { /* LCOV_EXCL_START */ - TDM_ERR("backedn(%s) no pp capability", private_backend->module_data->name); + TDM_ERR("backedn(%s) no pp capability", private_module->module_data->name); if (error) *error = TDM_ERROR_NO_CAPABILITY; return NULL; /* LCOV_EXCL_STOP */ } - pp_backend = func_display->display_create_pp(private_backend->bdata, &ret); + pp_module = func_display->display_create_pp(private_module->bdata, &ret); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ if (error) @@ -242,7 +242,7 @@ tdm_pp_create_internal(tdm_private_backend *private_backend, tdm_error *error) if (!private_pp) { /* LCOV_EXCL_START */ TDM_ERR("failed: alloc memory"); - func_pp->pp_destroy(pp_backend); + func_pp->pp_destroy(pp_module); if (error) *error = TDM_ERROR_OUT_OF_MEMORY; return NULL; @@ -252,18 +252,18 @@ tdm_pp_create_internal(tdm_private_backend *private_backend, tdm_error *error) ret = tdm_thread_cb_add(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL); if (ret != TDM_ERROR_NONE) { TDM_ERR("pp tdm_thread_cb_add failed"); - func_pp->pp_destroy(pp_backend); + func_pp->pp_destroy(pp_module); free(private_pp); if (error) *error = ret; return NULL; } - ret = func_pp->pp_set_done_handler(pp_backend, _tdm_pp_cb_done, private_pp); + ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp); if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ TDM_ERR("spp(%p) et pp_done_handler failed", private_pp); - func_pp->pp_destroy(pp_backend); + func_pp->pp_destroy(pp_module); free(private_pp); if (error) *error = ret; @@ -275,10 +275,10 @@ tdm_pp_create_internal(tdm_private_backend *private_backend, tdm_error *error) while (_tdm_pp_find_object(private_display, private_pp->stamp)) private_pp->stamp++; - LIST_ADD(&private_pp->link, &private_backend->pp_list); - private_pp->private_display = private_backend->private_display; - private_pp->private_backend = private_backend; - private_pp->pp_backend = pp_backend; + LIST_ADD(&private_pp->link, &private_module->pp_list); + private_pp->private_display = private_module->private_display; + private_pp->private_module = private_module; + private_pp->pp_module = pp_module; private_pp->owner_tid = syscall(SYS_gettid); LIST_INITHEAD(&private_pp->pending_buffer_list); @@ -294,7 +294,7 @@ INTERN void tdm_pp_destroy_internal(tdm_private_pp *private_pp) { tdm_private_display *private_display; - tdm_private_backend *private_backend; + tdm_private_module *private_module; tdm_func_pp *func_pp; tdm_pp_private_buffer *b = NULL, *bb = NULL; struct list_head clone_list; @@ -307,12 +307,12 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) tdm_thread_cb_remove(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL); private_display = private_pp->private_display; - private_backend = private_pp->private_backend; - func_pp = &private_backend->func_pp; + private_module = private_pp->private_module; + func_pp = &private_module->func_pp; LIST_DEL(&private_pp->link); - func_pp->pp_destroy(private_pp->pp_backend); + func_pp->pp_destroy(private_pp->pp_module); if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) { TDM_WRN("pp(%p) not finished:", private_pp); @@ -414,7 +414,7 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) FOURCC_STR(info->dst_config.format), info->transform, info->sync, info->flags); - ret = func_pp->pp_set_info(private_pp->pp_backend, info); + ret = func_pp->pp_set_info(private_pp->pp_module, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); private_pp->info = *info; @@ -468,15 +468,15 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) /* LCOV_EXCL_STOP */ } - if (tdm_backend_check_module_abi(private_backend, 1, 2) && - private_backend->caps_pp.max_attach_count > 0) { + if (tdm_module_check_abi(private_module, 1, 2) && + private_module->caps_pp.max_attach_count > 0) { /* LCOV_EXCL_START */ int length = LIST_LENGTH(&private_pp->pending_buffer_list) + LIST_LENGTH(&private_pp->buffer_list); - if (length >= private_backend->caps_pp.max_attach_count) { + if (length >= private_module->caps_pp.max_attach_count) { _pthread_mutex_unlock(&private_display->lock); TDM_DBG("failed: backend(%s) too many attached!! max_attach_count(%d)", - private_backend->module_data->name, private_backend->caps_pp.max_attach_count); + private_module->module_data->name, private_module->caps_pp.max_attach_count); return TDM_ERROR_BAD_REQUEST; } /* LCOV_EXCL_STOP */ @@ -500,7 +500,7 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) /* LCOV_EXCL_STOP */ } - ret = func_pp->pp_attach(private_pp->pp_backend, src, dst); + ret = func_pp->pp_attach(private_pp->pp_module, src, dst); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); if (ret != TDM_ERROR_NONE) { @@ -557,7 +557,7 @@ tdm_pp_commit(tdm_pp *pp) LIST_ADDTAIL(&b->commit_link, &commit_buffer_list); } - ret = func_pp->pp_commit(private_pp->pp_backend); + ret = func_pp->pp_commit(private_pp->pp_module); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) { diff --git a/src/tdm_private.h b/src/tdm_private.h index 458ae3c..4cb34e4 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -88,7 +88,7 @@ tdm_private_display * tdm_display_get(void); int -tdm_backend_check_module_abi(tdm_private_backend *private_backend, int abimaj, int abimin); +tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin); void * tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp); @@ -166,7 +166,7 @@ tdm_vblank_get_vblank_list_information(tdm_display *dpy, char *reply, int *len); tdm_error tdm_pp_init(tdm_private_display *private_display); tdm_private_pp * -tdm_pp_create_internal(tdm_private_backend *private_backend, tdm_error *error); +tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error); void tdm_pp_destroy_internal(tdm_private_pp *private_pp); @@ -228,7 +228,7 @@ extern int tdm_dump_enable; extern char *tdm_debug_dump_dir; tdm_error -tdm_display_update_output(tdm_private_backend *private_backend, +tdm_display_update_output(tdm_private_module *private_module, tdm_output *output_backend, int pipe, unsigned int need_new_caps); tdm_error tdm_display_enable_debug_module(const char*modules); diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index 2b6d25d..d1c132d 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -96,7 +96,7 @@ typedef enum { TDM_COMMIT_TYPE_LAYER, } tdm_commit_type; -typedef struct _tdm_private_backend tdm_private_backend; +typedef struct _tdm_private_module tdm_private_module; typedef struct _tdm_private_display tdm_private_display; typedef struct _tdm_private_output tdm_private_output; typedef struct _tdm_private_layer tdm_private_layer; @@ -115,7 +115,7 @@ typedef struct _tdm_private_output_hwc_target_buffer_window_commit_handler tdm_p typedef struct _tdm_private_layer_buffer tdm_private_layer_buffer; -struct _tdm_private_backend { +struct _tdm_private_module { struct list_head link; tdm_private_display *private_display; @@ -161,10 +161,10 @@ struct _tdm_private_display { tbm_bufmgr bufmgr; #endif - struct list_head backend_list; - tdm_private_backend *current_backend; //setted only when loading - tdm_private_backend *pp_backend; //pp-support backend - tdm_private_backend *capture_backend; //TODO: remove later + struct list_head module_list; + tdm_private_module *current_module; //setted only when loading + tdm_private_module *pp_module; //pp-support backend + tdm_private_module *capture_module; //TODO: remove later /* for event handling */ tdm_private_loop *private_loop; @@ -175,7 +175,7 @@ struct _tdm_private_display { struct _tdm_private_output { struct list_head link; - tdm_private_backend *private_backend; + tdm_private_module *private_module; int index; double stamp; @@ -237,7 +237,7 @@ struct _tdm_private_output { struct _tdm_private_layer { struct list_head link; - tdm_private_backend *private_backend; + tdm_private_module *private_module; int index; @@ -285,13 +285,13 @@ struct _tdm_private_hwc_window { struct _tdm_private_pp { struct list_head link; - tdm_private_backend *private_backend; + tdm_private_module *private_module; double stamp; tdm_private_display *private_display; - tdm_pp *pp_backend; + tdm_pp *pp_module; struct list_head pending_buffer_list; struct list_head buffer_list; @@ -307,7 +307,7 @@ struct _tdm_private_capture { struct list_head link; struct list_head display_link; - tdm_private_backend *private_backend; + tdm_private_module *private_module; double stamp; @@ -317,7 +317,7 @@ struct _tdm_private_capture { tdm_private_output *private_output; tdm_private_layer *private_layer; - tdm_capture *capture_backend; + tdm_capture *capture_module; struct list_head pending_buffer_list; struct list_head buffer_list; diff --git a/utests/src/ut_tdm_display.cpp b/utests/src/ut_tdm_display.cpp index 34903d8..054786b 100644 --- a/utests/src/ut_tdm_display.cpp +++ b/utests/src/ut_tdm_display.cpp @@ -383,7 +383,7 @@ TEST_P(TDMDisplay, BackendGetInfo) ASSERT_TRUE(count > 0); for (o = 0; o < count; o++) { - tdm_backend *backend; + tdm_module *module; const char *name = (const char *)TDM_UT_INVALID_VALUE; const char *vendor = (const char *)TDM_UT_INVALID_VALUE; int major = TDM_UT_INVALID_VALUE; @@ -393,11 +393,11 @@ TEST_P(TDMDisplay, BackendGetInfo) ASSERT_TRUE(ret == TDM_ERROR_NONE); ASSERT_TRUE(output != NULL); - backend = tdm_output_get_backend(output, &ret); + module = tdm_output_get_backend_module(output, &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(backend != NULL); + ASSERT_TRUE(module != NULL); - ASSERT_TRUE(tdm_backend_get_info(backend, &name, &vendor, &major, &minor) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_module_get_info(module, &name, &vendor, &major, &minor) == TDM_ERROR_NONE); ASSERT_TRUE(name != (const char *)TDM_UT_INVALID_VALUE); ASSERT_TRUE(vendor != (const char *)TDM_UT_INVALID_VALUE); ASSERT_TRUE(major != TDM_UT_INVALID_VALUE); @@ -412,7 +412,7 @@ TEST_P(TDMDisplay, BackendGetInfoNullObject) int major = TDM_UT_INVALID_VALUE; int minor = TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_backend_get_info(NULL, &name, &vendor, &major, &minor) == TDM_ERROR_INVALID_PARAMETER); + ASSERT_TRUE(tdm_module_get_info(NULL, &name, &vendor, &major, &minor) == TDM_ERROR_INVALID_PARAMETER); ASSERT_TRUE(name == (const char *)TDM_UT_INVALID_VALUE); ASSERT_TRUE(vendor == (const char *)TDM_UT_INVALID_VALUE); ASSERT_TRUE(major == TDM_UT_INVALID_VALUE); @@ -429,17 +429,17 @@ TEST_P(TDMDisplay, BackendGetInfoNullOther) ASSERT_TRUE(count > 0); for (o = 0; o < count; o++) { - tdm_backend *backend; + tdm_module *module; output = tdm_display_get_output(dpy, o, &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); ASSERT_TRUE(output != NULL); - backend = tdm_output_get_backend(output, &ret); + module = tdm_output_get_backend_module(output, &ret); ASSERT_TRUE(ret == TDM_ERROR_NONE); - ASSERT_TRUE(backend != NULL); + ASSERT_TRUE(module != NULL); - ASSERT_TRUE(tdm_backend_get_info(backend, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); + ASSERT_TRUE(tdm_module_get_info(module, NULL, NULL, NULL, NULL) == TDM_ERROR_NONE); } } diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 0ff6ffa..4556178 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -276,32 +276,32 @@ ut_tdm_output_get_vblank_interval_time(tdm_output *output) #ifdef UT_TDM_OUTPUT_ENABLE -TEST_P(TDMOutput, OutputGetBackend) +TEST_P(TDMOutput, OutputGetBackendModule) { TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_backend(outputs[o], &ret) != NULL); + ASSERT_TRUE(tdm_output_get_backend_module(outputs[o], &ret) != NULL); ASSERT_TRUE(ret == TDM_ERROR_NONE); } } -TEST_P(TDMOutput, OutputGetBackendNullOBject) +TEST_P(TDMOutput, OutputGetBackendModuleNullOBject) { TDM_UT_SKIP_FLAG(has_outputs); tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE; - ASSERT_TRUE(tdm_output_get_backend(NULL, &ret) == NULL); + ASSERT_TRUE(tdm_output_get_backend_module(NULL, &ret) == NULL); ASSERT_TRUE(ret == TDM_ERROR_INVALID_PARAMETER); } -TEST_P(TDMOutput, OutputGetBackendNullOther) +TEST_P(TDMOutput, OutputGetBackendModuleNullOther) { TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - ASSERT_TRUE(tdm_output_get_backend(outputs[o], NULL) != NULL); + ASSERT_TRUE(tdm_output_get_backend_module(outputs[o], NULL) != NULL); } } -- 2.7.4 From a79ec291f05858ae09188f5edb1c692d9d9b78c4 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Tue, 27 Feb 2018 16:45:05 +0900 Subject: [PATCH 05/16] utest: add ut_tdm_output_hwc test case Change-Id: Ic4f81b512034c947143eb8ca44e0f5b4e9dd0009 --- utests/Makefile.am | 1 + utests/src/ut_tdm.h | 3 +- utests/src/ut_tdm_hwc_window.cpp | 388 --------------------------------- utests/src/ut_tdm_output_hwc.cpp | 447 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 450 insertions(+), 389 deletions(-) create mode 100644 utests/src/ut_tdm_output_hwc.cpp diff --git a/utests/Makefile.am b/utests/Makefile.am index 90b01ac..e4624ca 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -11,6 +11,7 @@ tdm_utests_SOURCES = \ src/ut_tdm_display.cpp \ src/ut_tdm_output.cpp \ src/ut_tdm_layer.cpp \ + src/ut_tdm_output_hwc.cpp \ src/ut_tdm_hwc_window.cpp \ src/ut_tdm_pp.cpp \ src/ut_tdm_capture.cpp \ diff --git a/utests/src/ut_tdm.h b/utests/src/ut_tdm.h index 0e3ff70..890f182 100644 --- a/utests/src/ut_tdm.h +++ b/utests/src/ut_tdm.h @@ -29,7 +29,8 @@ extern "C" { #define UT_TDM_ENV_ENABLE #define UT_TDM_EVENT_LOOP_ENABLE #define UT_TDM_HELPER_ENABLE -#define UT_TDM_HWC_WINDOW_ENABLE +#define UT_TDM_OUTPUT_HWC_ENABLE +//#define UT_TDM_HWC_WINDOW_ENABLE #define UT_TDM_LAYER_ENABLE #define UT_TDM_LOG_ENABLE #define UT_TDM_OUTPUT_ENABLE diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index 1c16d4e..a5a5152 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -218,29 +218,6 @@ protected: }; -/* tdm_hwc_window * tdm_output_hwc_create_window(tdm_output *output, tdm_error *error); */ -TEST_F(TDMOutputHwc, CreateWindowFailNull) -{ - ASSERT_EQ(NULL, tdm_output_hwc_create_window(NULL, &error)); - ASSERT_NE(TDM_ERROR_NONE, error); -} - -TEST_F(TDMOutputHwc, CreateWindowSuccessful) -{ - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - tdm_hwc_window * hw = tdm_output_hwc_create_window(outputs[i], &error); - ASSERT_EQ(TDM_ERROR_NONE, error); - error = tdm_output_hwc_destroy_window(outputs[i], hw); - ASSERT_EQ(TDM_ERROR_NONE, error); - } else { - ASSERT_EQ(NULL, tdm_output_hwc_create_window(outputs[i], &error)); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} - - /* tdm_error tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window); */ TEST_F(TDMOutputHwc, DestroyWindowFailNull) { @@ -276,122 +253,6 @@ TEST_F(TDMOutputHwc, DestroyWindowSuccessful) } -/* tdm_error tdm_output_hwc_set_client_target_buffer(tdm_output *output, - tbm_surface_h target_buffer, tdm_hwc_region damage, - tdm_hwc_window *composited_wnds, uint32_t num_wnds); */ -/* TDOO: need to be fixed -TEST_F(TDMOutputHwc, SetClientTargetBufferFailNullOutput) -{ - tdm_hwc_region reg; - tbm_surface_h target_buff = CreateBufferForOutput(0); - error = tdm_output_hwc_set_client_target_buffer(NULL, target_buff, reg, NULL, 0 ); - tbm_surface_internal_destroy(target_buff); - ASSERT_NE(TDM_ERROR_NONE, error); -} - -TEST_F(TDMOutputHwcWithoutHwcCap, SetClientTargetBufferFailNoHwc) -{ - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; - - for (int i = 0; i < output_count; i++) { - tbm_surface_h target_buff = CreateBufferForOutput(i); - ASSERT_NE(NULL, target_buff); - error = tdm_output_hwc_set_client_target_buffer(outputs[i], target_buff, damage, NULL, 0); - tbm_surface_internal_destroy(target_buff); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -TEST_F(TDMOutputHwc, SetClientTargetBufferSuccessfulSetBuff) -{ - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; - - for (int i = 0; i < output_count; i++) { - tbm_surface_h target_buff = CreateBufferForOutput(i); - ASSERT_NE(NULL, target_buff); - if (IsHwcEnable(i)) { - error = tdm_output_hwc_set_client_target_buffer(outputs[i], target_buff, damage, - NULL, 0); - tbm_surface_internal_destroy(target_buff); - ASSERT_EQ(TDM_ERROR_NONE, error); - } else { - error = tdm_output_hwc_set_client_target_buffer(outputs[i], target_buff, damage, - NULL, 0); - tbm_surface_internal_destroy(target_buff); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} - -TEST_F(TDMOutputHwc, SetClientTargetBufferSuccessfulResetBuff) -{ - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; - - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - error = tdm_output_hwc_set_client_target_buffer(outputs[i], NULL, damage, - NULL, 0); - ASSERT_EQ(TDM_ERROR_NONE, error); - } else { - error = tdm_output_hwc_set_client_target_buffer(outputs[i], NULL, damage, - NULL, 0); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} -*/ - -/* tbm_surface_queue_h tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error); */ -TEST_F(TDMOutputHwc, GetTargetBufferQueueFailNullObject) -{ - tbm_surface_queue_h queue = NULL; - - queue = tdm_output_hwc_get_target_buffer_queue(NULL, &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); - - queue = tdm_output_hwc_get_target_buffer_queue(NULL, NULL); - ASSERT_EQ(NULL, queue); -} - -TEST_F(TDMOutputHwcWithoutHwcCap, GetTargetBufferQueueFainNoHwc) -{ - tbm_surface_queue_h queue = NULL; - - for (int i = 0; i < output_count; i++) { - queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); - } -} - -TEST_F(TDMOutputHwc, GetTargetBufferQueueSuccessful) -{ - tbm_surface_queue_h queue = NULL; - - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], &error); - tbm_surface_queue_destroy(queue); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, queue); - - queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], NULL); - tbm_surface_queue_destroy(queue); - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, queue); - } else { - queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], &error); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); - - queue = tdm_output_hwc_get_target_buffer_queue(outputs[i], NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - ASSERT_EQ(NULL, queue); - } - } -} - /* tbm_surface_queue_h tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); */ TEST_F(TDMHwcWindow, GetBufferQueueFailNull) { @@ -611,255 +472,6 @@ TEST_F(TDMHwcWindow, VideoGetCapabilitySuccessful) } } -/* tdm_error tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds, uint32_t num_wnds, - uint32_t *num_types); */ -/* TODO: fix the validate test later. -TEST_F(TDMOutputHwc, ValidateFailNull) -{ - uint32_t num_types; - error = tdm_output_hwc_validate(NULL, NULL, 0, &num_types); - ASSERT_NE(TDM_ERROR_NONE, error); - - if (outputs[0]) { - error = tdm_output_hwc_validate(outputs[0], NULL, 0, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -TEST_F(TDMOutputHwcWithoutHwcCap, ValidateFailNoHwc) -{ - uint32_t num_types; - - for (int i = 0; i < output_count; i++) { - error = tdm_output_hwc_validate(outputs[i], &num_types); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -TEST_F(TDMOutputHwc, ValidateSuccessful) -{ - uint32_t num_types; - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - error = tdm_output_hwc_validate(outputs[i], &num_types); - ASSERT_EQ(TDM_ERROR_NONE, error); - } else { - error = tdm_output_hwc_validate(outputs[i], &num_types); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} -TODO: */ - -/* tdm_error tdm_output_hwc_get_changed_composition_types(tdm_output *output, - uint32_t *num_elements, tdm_hwc_window **hwc_window, - tdm_hwc_window_composition *composition_types); */ - -TEST_F(TDMOutputHwc, GetChangedCompositionTypesFailNull) -{ - uint32_t num_elements; - - error = tdm_output_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - - if (outputs[0]) { - error = tdm_output_hwc_get_changed_composition_types(outputs[0], NULL, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -TEST_F(TDMOutputHwcWithoutHwcCap, GetChangedCompositionTypesFailNoHwc) -{ - uint32_t get_num = 10; - - for (int i = 0; i < output_count; i++) { - error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -/* TODO: fix the validate test later. -TEST_F(TDMHwcWindow, GetChangedCompositionTypesSuccessful) -{ - uint32_t validate_num; - uint32_t get_num = 0; - - tdm_hwc_window_composition *composition_types; - tdm_hwc_window **hwc_wnds; - - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_DEVICE); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - - - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - error = tdm_output_hwc_validate(outputs[i], &validate_num); - ASSERT_EQ(TDM_ERROR_NONE, error); - - error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, NULL, NULL); - ASSERT_EQ(TDM_ERROR_NONE, error); - - ASSERT_TRUE(get_num == validate_num); - hwc_wnds = (tdm_hwc_window **)calloc(get_num, sizeof(tdm_hwc_window *)); - composition_types = (tdm_hwc_window_composition *)calloc(get_num, sizeof(tdm_hwc_window_composition)); - - error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, hwc_wnds, composition_types); - - free(hwc_wnds); - free(composition_types); - - ASSERT_EQ(TDM_ERROR_NONE, error); - } else { - error = tdm_output_hwc_get_changed_composition_types(outputs[i], &get_num, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} -*/ - -/* tdm_error tdm_output_hwc_accept_changes(tdm_output *output); */ - -TEST_F(TDMOutputHwc, AcceptChangesFailNull) -{ - error = tdm_output_hwc_accept_changes(NULL); - ASSERT_NE(TDM_ERROR_NONE, error); -} - -TEST_F(TDMOutputHwcWithoutHwcCap, AcceptChangesFailNoHwc) -{ - for (int i = 0; i < output_count; i++) { - error = tdm_output_hwc_accept_changes(outputs[i]); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -/* TODO: fix the validate test later. -TEST_F(TDMHwcWindow, AcceptChangesSuccessful) -{ - uint32_t validate_num; - - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_DEVICE); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - error = tdm_output_hwc_validate(outputs[i], &validate_num); - ASSERT_EQ(TDM_ERROR_NONE, error); - - if (validate_num > 0) { - error = tdm_output_hwc_accept_changes(outputs[i]); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - } - } -} -*/ - -static int need_validate_handler_is_called = 0; -static void need_validate_handler(tdm_output *output) -{ - need_validate_handler_is_called = 1; -} -/* tdm_error tdm_output_hwc_set_need_validate_handler(tdm_output *output, - tdm_output_need_validate_handler hndl); */ -TEST_F(TDMOutputHwc, SetNeedValidateHandlerFailNull) -{ - error = tdm_output_hwc_set_need_validate_handler(NULL, &need_validate_handler); - ASSERT_NE(TDM_ERROR_NONE, error); - - error = tdm_output_hwc_set_need_validate_handler(outputs[0], NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - -} - -TEST_F(TDMOutputHwcWithoutHwcCap, SetNeedValidateHandlerFailNoHwc) -{ - for (int i = 0; i < output_count; i++) { - error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); - ASSERT_NE(TDM_ERROR_NONE, error); - } -} - -TEST_F(TDMOutputHwc, SetNeedValidateHandlerSuccessful) -{ - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - /* - * This event can't be generated form user side. - * So just check a set and double set - */ - - /* test: first set*/ - error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); - ASSERT_EQ(TDM_ERROR_NONE, error); - /* test: second isn't allowed*/ - error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); - ASSERT_NE(TDM_ERROR_NONE, error); - } else { - error = tdm_output_hwc_set_need_validate_handler(outputs[i], &need_validate_handler); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} - -/* tdm_hwc_window * tdm_output_hwc_create_video_window(tdm_output *output, tdm_error *error); */ -TEST_F(TDMOutputHwc, CreateVideoWindowFailNull) -{ - ASSERT_EQ(NULL, tdm_output_hwc_create_video_window(NULL, &error)); - ASSERT_NE(TDM_ERROR_NONE, error); -} - -TEST_F(TDMOutputHwc, CreateVideoWindowSuccessful) -{ - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - tdm_hwc_window * hw = tdm_output_hwc_create_video_window(outputs[i], &error); - if (error != TDM_ERROR_NOT_IMPLEMENTED) { - ASSERT_EQ(TDM_ERROR_NONE, error); - ASSERT_NE(NULL, hw); - error = tdm_output_hwc_destroy_window(outputs[i], hw); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - } else { - ASSERT_EQ(NULL, tdm_output_hwc_create_video_window(outputs[i], &error)); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} - -/* tdm_output_hwc_get_video_supported_formats() */ -TEST_F(TDMOutputHwc, GetVideoSupportedFormatsFailNull) -{ - tdm_error error; - - error = tdm_output_hwc_get_video_supported_formats(NULL, NULL, NULL); - ASSERT_NE(TDM_ERROR_NONE, error); -} - -TEST_F(TDMOutputHwc, GetVideoSupportedFormatsSuccessful) -{ - tdm_error error; - const tbm_format *formats; - int count; - - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - error = tdm_output_hwc_get_video_supported_formats(outputs[i], &formats, &count); - if (error != TDM_ERROR_NOT_IMPLEMENTED) { - ASSERT_EQ(TDM_ERROR_NONE, error); - if (count > 0) - ASSERT_NE(NULL, formats); - } - } else { - error = tdm_output_hwc_get_video_supported_formats(outputs[i], &formats, &count); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } -} /* tdm_hwc_window_video_get_available_properties() */ TEST_F(TDMHwcWindow, GetAvailablePropertiesFailNullWin) diff --git a/utests/src/ut_tdm_output_hwc.cpp b/utests/src/ut_tdm_output_hwc.cpp new file mode 100644 index 0000000..1b0aa24 --- /dev/null +++ b/utests/src/ut_tdm_output_hwc.cpp @@ -0,0 +1,447 @@ +/************************************************************************** + * + * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: Konstantin Drabeniuk + * Contact: Andrii Sokolenko + * Contact: Roman Marchenko + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * +**************************************************************************/ + +#include "ut_tdm.h" + +class TDMOutputHwc : public TDMOutput { +public: + TDMOutputHwc(); + void SetUp(void); + void TearDown(void); + + tdm_error error; +}; + +TDMOutputHwc::TDMOutputHwc() +{ + ; +} + +void TDMOutputHwc::SetUp(void) +{ + TDMOutput::SetUp(); +} + +void TDMOutputHwc::TearDown(void) +{ + TDMOutput::TearDown(); +} + +#ifdef UT_TDM_OUTPUT_HWC_ENABLE + +/* tdm_hwc_window * tdm_output_hwc_create_window(tdm_output *output, tdm_error *error); */ +TEST_P(TDMOutputHwc, CreateWindowFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + ASSERT_EQ(NULL, tdm_output_hwc_create_window(NULL, &error)); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_P(TDMOutputHwc, CreateWindowSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_window * hw = NULL; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + hw = tdm_output_hwc_create_window(outputs[o], &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + error = tdm_output_hwc_destroy_window(outputs[o], hw); + ASSERT_EQ(TDM_ERROR_NONE, error); + } else { + ASSERT_EQ(NULL, tdm_output_hwc_create_window(outputs[o], &error)); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} + +/* tdm_error tdm_output_hwc_set_client_target_buffer(tdm_output *output, + tbm_surface_h target_buffer, tdm_hwc_region damage, + tdm_hwc_window *composited_wnds, uint32_t num_wnds); */ +/* TDOO: need to be fixed +TEST_P(TDMOutputHwc, SetClientTargetBufferFailNullOutput) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_region reg; + tbm_surface_h target_buff = CreateBufferForOutput(0); + error = tdm_output_hwc_set_client_target_buffer(NULL, target_buff, reg, NULL, 0 ); + tbm_surface_internal_destroy(target_buff); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_P(TDMOutputHwc, SetClientTargetBufferFailNoHwc) +{ + tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + + for (int o = 0; o < output_count; o++) { + tbm_surface_h target_buff = CreateBufferForOutput(i); + ASSERT_NE(NULL, target_buff); + error = tdm_output_hwc_set_client_target_buffer(outputs[o], target_buff, damage, NULL, 0); + tbm_surface_internal_destroy(target_buff); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulSetBuff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + + for (int o = 0; o < output_count; o++) { + tbm_surface_h target_buff = CreateBufferForOutput(i); + ASSERT_NE(NULL, target_buff); + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_set_client_target_buffer(outputs[o], target_buff, damage, + NULL, 0); + tbm_surface_internal_destroy(target_buff); + ASSERT_EQ(TDM_ERROR_NONE, error); + } else { + error = tdm_output_hwc_set_client_target_buffer(outputs[o], target_buff, damage, + NULL, 0); + tbm_surface_internal_destroy(target_buff); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} + +TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulResetBuff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_set_client_target_buffer(outputs[o], NULL, damage, + NULL, 0); + ASSERT_EQ(TDM_ERROR_NONE, error); + } else { + error = tdm_output_hwc_set_client_target_buffer(outputs[o], NULL, damage, + NULL, 0); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} +*/ + +/* tbm_surface_queue_h tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error); */ +TEST_P(TDMOutputHwc, GetTargetBufferQueueFailNullObject) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tbm_surface_queue_h queue = NULL; + + queue = tdm_output_hwc_get_target_buffer_queue(NULL, &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, queue); + + queue = tdm_output_hwc_get_target_buffer_queue(NULL, NULL); + ASSERT_EQ(NULL, queue); +} + +TEST_P(TDMOutputHwc, GetTargetBufferQueueFainNoHwc) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tbm_surface_queue_h queue = NULL; + + for (int o = 0; o < output_count; o++) { + queue = tdm_output_hwc_get_target_buffer_queue(outputs[o], &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, queue); + } +} + +TEST_P(TDMOutputHwc, GetTargetBufferQueueSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tbm_surface_queue_h queue = NULL; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + queue = tdm_output_hwc_get_target_buffer_queue(outputs[o], &error); + tbm_surface_queue_destroy(queue); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, queue); + + queue = tdm_output_hwc_get_target_buffer_queue(outputs[o], NULL); + tbm_surface_queue_destroy(queue); + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, queue); + } else { + queue = tdm_output_hwc_get_target_buffer_queue(outputs[o], &error); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, queue); + + queue = tdm_output_hwc_get_target_buffer_queue(outputs[o], NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + ASSERT_EQ(NULL, queue); + } + } +} + +/* tdm_error tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds, uint32_t num_wnds, + uint32_t *num_types); */ +/* TODO: fix the validate test later. +TEST_P(TDMOutputHwc, ValidateFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t num_types; + error = tdm_output_hwc_validate(NULL, NULL, 0, &num_types); + ASSERT_NE(TDM_ERROR_NONE, error); + + if (outputs[0]) { + error = tdm_output_hwc_validate(outputs[0], NULL, 0, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_P(TDMOutputHwc, ValidateFailNoHwc) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t num_types; + + for (int o = 0; o < output_count; o++) { + error = tdm_output_hwc_validate(outputs[o], &num_types); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_P(TDMOutputHwc, ValidateSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t num_types; + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_validate(outputs[o], &num_types); + ASSERT_EQ(TDM_ERROR_NONE, error); + } else { + error = tdm_output_hwc_validate(outputs[o], &num_types); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} +TODO: */ + +/* tdm_error tdm_output_hwc_get_changed_composition_types(tdm_output *output, + uint32_t *num_elements, tdm_hwc_window **hwc_window, + tdm_hwc_window_composition *composition_types); */ + +TEST_P(TDMOutputHwc, GetChangedCompositionTypesFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t num_elements; + + error = tdm_output_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + + if (outputs[0]) { + error = tdm_output_hwc_get_changed_composition_types(outputs[0], NULL, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +TEST_P(TDMOutputHwc, GetChangedCompositionTypesFailNoHwc) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t get_num = 10; + + for (int o = 0; o < output_count; o++) { + error = tdm_output_hwc_get_changed_composition_types(outputs[o], &get_num, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +/* TODO: fix the validate test later. +TEST_P(TDMHwcWindow, GetChangedCompositionTypesSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t validate_num; + uint32_t get_num = 0; + + tdm_hwc_window_composition *composition_types; + tdm_hwc_window **hwc_wnds; + + for (int i = 0; i < hwc_count; i++) { + error = tdm_hwc_window_set_composition_type(hwc_wins[o], TDM_COMPOSITION_DEVICE); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + + + for (int i = 0; i < output_count; i++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_validate(outputs[o], &validate_num); + ASSERT_EQ(TDM_ERROR_NONE, error); + + error = tdm_output_hwc_get_changed_composition_types(outputs[o], &get_num, NULL, NULL); + ASSERT_EQ(TDM_ERROR_NONE, error); + + ASSERT_TRUE(get_num == validate_num); + hwc_wnds = (tdm_hwc_window **)calloc(get_num, sizeof(tdm_hwc_window *)); + composition_types = (tdm_hwc_window_composition *)calloc(get_num, sizeof(tdm_hwc_window_composition)); + + error = tdm_output_hwc_get_changed_composition_types(outputs[o], &get_num, hwc_wnds, composition_types); + + free(hwc_wnds); + free(composition_types); + + ASSERT_EQ(TDM_ERROR_NONE, error); + } else { + error = tdm_output_hwc_get_changed_composition_types(outputs[o], &get_num, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} +*/ + +/* tdm_error tdm_output_hwc_accept_changes(tdm_output *output); */ + +TEST_P(TDMOutputHwc, AcceptChangesFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + error = tdm_output_hwc_accept_changes(NULL); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_P(TDMOutputHwc, AcceptChangesFailNoHwc) +{ + for (int o = 0; o < output_count; o++) { + error = tdm_output_hwc_accept_changes(outputs[o]); + ASSERT_NE(TDM_ERROR_NONE, error); + } +} + +/* TODO: fix the validate test later. +TEST_P(TDMHwcWindow, AcceptChangesSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + uint32_t validate_num; + + for (int i = 0; i < hwc_count; i++) { + error = tdm_hwc_window_set_composition_type(hwc_wins[o], TDM_COMPOSITION_DEVICE); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + + for (int i = 0; i < output_count; i++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_validate(outputs[o], &validate_num); + ASSERT_EQ(TDM_ERROR_NONE, error); + + if (validate_num > 0) { + error = tdm_output_hwc_accept_changes(outputs[o]); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + } + } +} +*/ + +/* tdm_hwc_window * tdm_output_hwc_create_video_window(tdm_output *output, tdm_error *error); */ +TEST_P(TDMOutputHwc, CreateVideoWindowFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + ASSERT_EQ(NULL, tdm_output_hwc_create_video_window(NULL, &error)); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_P(TDMOutputHwc, CreateVideoWindowSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_window *hw = NULL; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + hw = tdm_output_hwc_create_video_window(outputs[o], &error); + if (error != TDM_ERROR_NOT_IMPLEMENTED) { + ASSERT_EQ(TDM_ERROR_NONE, error); + ASSERT_NE(NULL, hw); + error = tdm_output_hwc_destroy_window(outputs[o], hw); + ASSERT_EQ(TDM_ERROR_NONE, error); + } + } else { + ASSERT_EQ(NULL, tdm_output_hwc_create_video_window(outputs[o], &error)); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} + +/* tdm_output_hwc_get_video_supported_formats() */ +TEST_P(TDMOutputHwc, GetVideoSupportedFormatsFailNull) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_error error; + + error = tdm_output_hwc_get_video_supported_formats(NULL, NULL, NULL); + ASSERT_NE(TDM_ERROR_NONE, error); +} + +TEST_P(TDMOutputHwc, GetVideoSupportedFormatsSuccessful) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_error error; + const tbm_format *formats; + int count; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + error = tdm_output_hwc_get_video_supported_formats(outputs[o], &formats, &count); + if (error != TDM_ERROR_NOT_IMPLEMENTED) { + ASSERT_EQ(TDM_ERROR_NONE, error); + if (count > 0) + ASSERT_NE(NULL, formats); + } + } else { + error = tdm_output_hwc_get_video_supported_formats(outputs[o], &formats, &count); + ASSERT_NE(TDM_ERROR_NONE, error); + } + } +} + +INSTANTIATE_TEST_CASE_P(TDMOutputHwcParams, + TDMOutputHwc, + Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); +#endif -- 2.7.4 From 22a7defce20cd39c32da437475e40ecf2be4230f Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Tue, 27 Feb 2018 17:25:27 +0900 Subject: [PATCH 06/16] utest: modify the TDMHwcWindow test case Change-Id: I9fb070f824ec134051f7245c923deaa989c10cdd --- utests/src/ut_tdm.h | 2 +- utests/src/ut_tdm_hwc_window.cpp | 393 +++++++++++++++------------------------ 2 files changed, 154 insertions(+), 241 deletions(-) diff --git a/utests/src/ut_tdm.h b/utests/src/ut_tdm.h index 890f182..c29a2b1 100644 --- a/utests/src/ut_tdm.h +++ b/utests/src/ut_tdm.h @@ -30,7 +30,7 @@ extern "C" { #define UT_TDM_EVENT_LOOP_ENABLE #define UT_TDM_HELPER_ENABLE #define UT_TDM_OUTPUT_HWC_ENABLE -//#define UT_TDM_HWC_WINDOW_ENABLE +#define UT_TDM_HWC_WINDOW_ENABLE #define UT_TDM_LAYER_ENABLE #define UT_TDM_LOG_ENABLE #define UT_TDM_OUTPUT_ENABLE diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index a5a5152..d18a161 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -30,223 +30,87 @@ #include "ut_tdm.h" -#ifdef UT_TDM_HWC_WINDOW_ENABLE - -class TDMOutputHwc : public ::testing::Test { -protected: - tdm_display *dpy = NULL; - tbm_bufmgr tbm_bufmgr = NULL; - int master_fd = TDM_UT_INVALID_VALUE; - /*list of connected outputs*/ - int output_count = 0; - const tdm_output_mode **preferred_mode_array = NULL; - tdm_output **outputs; - tdm_error error ; - virtual void SetEnv() - { - setenv("TDM_HWC", "1", 1); - setenv("XDG_RUNTIME_DIR", "/run", 1); - setenv("TBM_DISPLAY_SERVER", "1", 1); - tdm_config_set_int(TDM_CONFIG_KEY_DEBUG_DLOG, 1); - tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_THREAD, 1); - tdm_config_set_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, 1); - tdm_config_set_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, "libtdm-default.so"); - } - - void UnsetEnv() - { - unsetenv("TDM_HWC"); - unsetenv("XDG_RUNTIME_DIR"); - unsetenv("TBM_DISPLAY_SERVER"); - } - - int IsHwcEnable(int i) - { - tdm_output_capability capabilities = (tdm_output_capability)0; - tdm_output_get_capabilities(outputs[i], &capabilities); - return capabilities & TDM_OUTPUT_CAPABILITY_HWC; - } - - tbm_surface_h CreateBufferForOutput(int i) - { - int w = preferred_mode_array[i]->hdisplay; - int h = preferred_mode_array[i]->vdisplay; - return tbm_surface_internal_create_with_flags(w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT); - } - - void SetUp(void) - { - const tdm_output_mode *preferred_mode = NULL; - tdm_error error = TDM_ERROR_NONE; - int all_output_count = 0; - outputs = NULL; - - SetEnv(); - - /* FIXME: fix the error. If we initialize TBM before TDM we get fail - * in the tdm_output_set_dpms */ -#if 0 - tbm_bufmgr = tbm_bufmgr_init(-1); - ASSERT_FALSE(tbm_bufmgr == NULL); -#endif - - dpy = tdm_display_init(&error); - ASSERT_TRUE(error == TDM_ERROR_NONE); - ASSERT_FALSE(dpy == NULL); - - master_fd = tbm_drm_helper_get_master_fd(); - ASSERT_TRUE(tdm_display_get_output_count(dpy, &all_output_count) == TDM_ERROR_NONE); - - outputs = (tdm_output **)calloc(all_output_count, sizeof(tdm_output *)); - ASSERT_FALSE(NULL == outputs); +#define HWC_WIN_NUM 5 - preferred_mode_array = (const tdm_output_mode **)calloc(all_output_count, sizeof(tdm_output_mode *)); - ASSERT_FALSE(NULL == preferred_mode_array); +class TDMHwcWindow : public TDMOutput { +public: + TDMHwcWindow(); + void SetUp(void); + void TearDown(void); - output_count = 0; + tdm_error error; + tdm_hwc_window **hwc_wins; + tdm_hwc_window *video_hwc_win; + int hwc_count; +}; - for (int i = 0; i < all_output_count; i++) { - tdm_output *output = tdm_display_get_output(dpy, i, &error); - int output_modes_cnt = 0; - const tdm_output_mode *output_modes; +TDMHwcWindow::TDMHwcWindow() +{ + hwc_count = 0; + video_hwc_win = NULL; +} - if (TDM_ERROR_NONE != error || NULL == output) - continue; +void TDMHwcWindow::SetUp(void) +{ + tdm_hwc_window *hw = NULL; - tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; - if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status)) - continue; + TDMOutput::SetUp(); - if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) - continue; + hwc_wins = (tdm_hwc_window **)calloc(output_count * HWC_WIN_NUM, sizeof(tdm_hwc_window *)); - error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt); - if (TDM_ERROR_NONE != error) - continue; - if (output_modes_cnt <= 0) { - continue; + //create HWC_WIN_NUM hwc_windows for each outputs + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + for (int w = 0; w < HWC_WIN_NUM; w++) { + hw = tdm_output_hwc_create_window(outputs[w], &error); + ASSERT_EQ(TDM_ERROR_NONE, error); + hwc_wins[hwc_count++] = hw; } - for(int j = 0; j < output_modes_cnt; j++) - if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED) - preferred_mode = &output_modes[j]; - - if (!preferred_mode) - continue; - - if (preferred_mode_array) - preferred_mode_array[output_count] = preferred_mode; - if (outputs) - outputs[output_count] = output; - output_count++; - - error = tdm_output_set_mode(output, preferred_mode); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - } - void TearDown(void) - { - tdm_display_deinit(dpy); - dpy = NULL; - tbm_bufmgr_deinit(tbm_bufmgr); - tbm_bufmgr = NULL; - if (outputs) - free(outputs); - if (preferred_mode_array) - free(preferred_mode_array); - if (master_fd > -1) { - int temp_master_fd = tbm_drm_helper_get_master_fd(); - EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl; - if (temp_master_fd > -1) - exit(1); - close(master_fd); - } - - UnsetEnv(); - } -}; - -class TDMOutputHwcWithoutHwcCap : public TDMOutputHwc { - void SetEnv() - { - TDMOutputHwc::SetEnv(); - setenv("TDM_HWC", "0", 1); - } -}; - -#define HWC_WIN_NUM 5 -class TDMHwcWindow : public TDMOutputHwc { -protected: - tdm_hwc_window **hwc_wins; - tdm_hwc_window *video_hwc_win; - int hwc_count; - - void SetUp(void) - { - hwc_count = 0; - video_hwc_win = NULL; - - TDMOutputHwc::SetUp(); - hwc_wins = (tdm_hwc_window **)calloc(output_count * HWC_WIN_NUM, sizeof(tdm_hwc_window *)); - - //create HWC_WIN_NUM hwc_windows for each outputs - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - for (int j = 0; j < HWC_WIN_NUM; j++) { - tdm_hwc_window * hw = tdm_output_hwc_create_window(outputs[i], &error); - ASSERT_EQ(TDM_ERROR_NONE, error); - hwc_wins[hwc_count++] = hw; - } - if (!video_hwc_win) { - video_hwc_win = tdm_output_hwc_create_video_window(outputs[i], &error); - } - } + if (!video_hwc_win) + video_hwc_win = tdm_output_hwc_create_video_window(outputs[o], &error); } } +} - void TearDown(void) - { - for (int i = 0; i < hwc_count; i++) { - tdm_output_hwc_destroy_window(outputs[0], hwc_wins[i]); - } +void TDMHwcWindow::TearDown(void) +{ + for (int w = 0; w < hwc_count; w++) + tdm_output_hwc_destroy_window(outputs[0], hwc_wins[w]); - if (video_hwc_win) - tdm_output_hwc_destroy_window(outputs[0], video_hwc_win); + if (video_hwc_win) + tdm_output_hwc_destroy_window(outputs[0], video_hwc_win); - TDMOutputHwc::TearDown(); - } + TDMOutput::TearDown(); +} -}; +#ifdef UT_TDM_HWC_WINDOW_ENABLE /* tdm_error tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window); */ -TEST_F(TDMOutputHwc, DestroyWindowFailNull) +TEST_P(TDMHwcWindow, DestroyWindowFailNull) { - for (int i = 0; i < output_count; i++) { - tdm_hwc_window * hw = NULL; - - if (IsHwcEnable(i)) { - hw = tdm_output_hwc_create_window(outputs[i], &error); - ASSERT_EQ(TDM_ERROR_NONE, error); - } - - /* test: output is NULL*/ - error = tdm_output_hwc_destroy_window(NULL, hw); - ASSERT_NE(TDM_ERROR_NONE, error); + TDM_UT_SKIP_FLAG(has_outputs); + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { /* test: hw is NULL*/ - error = tdm_output_hwc_destroy_window(outputs[i], NULL); + error = tdm_output_hwc_destroy_window(outputs[o], NULL); ASSERT_NE(TDM_ERROR_NONE, error); + } } } -TEST_F(TDMOutputHwc, DestroyWindowSuccessful) +TEST_P(TDMHwcWindow, DestroyWindowSuccessful) { - tdm_hwc_window * hw; - for (int i = 0; i < output_count; i++) { - if (IsHwcEnable(i)) { - hw = tdm_output_hwc_create_window(outputs[i], &error); + TDM_UT_SKIP_FLAG(has_outputs); + + tdm_hwc_window *hw = NULL; + + for (int o = 0; o < output_count; o++) { + if (ut_tdm_output_is_hwc_enable(outputs[o])) { + hw = tdm_output_hwc_create_window(outputs[o], &error); ASSERT_EQ(TDM_ERROR_NONE, error); - error = tdm_output_hwc_destroy_window(outputs[i], hw); + error = tdm_output_hwc_destroy_window(outputs[o], hw); ASSERT_EQ(TDM_ERROR_NONE, error); } } @@ -254,8 +118,10 @@ TEST_F(TDMOutputHwc, DestroyWindowSuccessful) /* tbm_surface_queue_h tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); */ -TEST_F(TDMHwcWindow, GetBufferQueueFailNull) +TEST_P(TDMHwcWindow, GetBufferQueueFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + tbm_surface_queue_h queue = NULL; queue = tdm_hwc_window_get_tbm_buffer_queue(NULL, &error); @@ -266,8 +132,10 @@ TEST_F(TDMHwcWindow, GetBufferQueueFailNull) ASSERT_EQ(NULL, queue); } -TEST_F(TDMHwcWindow, GetBufferQueueSuccessful) +TEST_P(TDMHwcWindow, GetBufferQueueSuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tbm_surface_queue_h queue = NULL; tdm_hwc_window_info info = { 0 }; @@ -277,16 +145,16 @@ TEST_F(TDMHwcWindow, GetBufferQueueSuccessful) info.dst_pos.h = info.dst_pos.w = 256; info.transform = TDM_TRANSFORM_NORMAL; - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_info(hwc_wins[i], &info); + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_info(hwc_wins[w], &info); ASSERT_EQ(TDM_ERROR_NONE, error); - queue = tdm_hwc_window_get_tbm_buffer_queue(hwc_wins[i], &error); + queue = tdm_hwc_window_get_tbm_buffer_queue(hwc_wins[w], &error); tbm_surface_queue_destroy(queue); ASSERT_EQ(TDM_ERROR_NONE, error); ASSERT_NE(NULL, queue); - queue = tdm_hwc_window_get_tbm_buffer_queue(hwc_wins[i], NULL); + queue = tdm_hwc_window_get_tbm_buffer_queue(hwc_wins[w], NULL); tbm_surface_queue_destroy(queue); ASSERT_NE(NULL, queue); } @@ -294,67 +162,81 @@ TEST_F(TDMHwcWindow, GetBufferQueueSuccessful) /* tdm_error tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, tdm_hwc_window_composition composition_type); */ -TEST_F(TDMHwcWindow, SetCompositionTypeFailNull) +TEST_P(TDMHwcWindow, SetCompositionTypeFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + error = tdm_hwc_window_set_composition_type(NULL, TDM_COMPOSITION_DEVICE); ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, SetCompositionTypeSuccessful) +TEST_P(TDMHwcWindow, SetCompositionTypeSuccessful) { - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_DEVICE); + TDM_UT_SKIP_FLAG(has_outputs); + + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_COMPOSITION_DEVICE); ASSERT_EQ(TDM_ERROR_NONE, error); - error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_CLIENT); + error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_COMPOSITION_CLIENT); ASSERT_EQ(TDM_ERROR_NONE, error); - error = tdm_hwc_window_set_composition_type(hwc_wins[i], TDM_COMPOSITION_CURSOR); + error = tdm_hwc_window_set_composition_type(hwc_wins[w], TDM_COMPOSITION_CURSOR); ASSERT_EQ(TDM_ERROR_NONE, error); } } -TEST_F(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) +TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) { - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_composition_type(hwc_wins[i], tdm_hwc_window_composition(TDM_COMPOSITION_NONE-1)); + TDM_UT_SKIP_FLAG(has_outputs); + + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_composition_type(hwc_wins[w], tdm_hwc_window_composition(TDM_COMPOSITION_NONE-1)); ASSERT_NE(TDM_ERROR_NONE, error); } } /* tdm_error tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region damage); */ -TEST_F(TDMHwcWindow, SetBufferDamageFailNullHwcWindow) +TEST_P(TDMHwcWindow, SetBufferDamageFailNullHwcWindow) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; error = tdm_hwc_window_set_buffer_damage(NULL, damage); ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, SetBufferDamageFailNullDamageRects) +TEST_P(TDMHwcWindow, SetBufferDamageFailNullDamageRects) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_region damage = {.num_rects = 1, .rects = NULL}; - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_buffer_damage(hwc_wins[i], damage); + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage); ASSERT_NE(TDM_ERROR_NONE, error); } } -TEST_F(TDMHwcWindow, SetBufferDamageSuccessful) +TEST_P(TDMHwcWindow, SetBufferDamageSuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_pos const rects[1] = {0}; tdm_hwc_region damage = {.num_rects = 1, .rects = rects}; - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_buffer_damage(hwc_wins[i], damage); + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage); ASSERT_EQ(TDM_ERROR_NONE, error); } } /* tdm_error tdm_hwc_window_set_info(tdm_hwc_window *hwc_window, tdm_hwc_window_info *info); */ -TEST_F(TDMHwcWindow, SetInfoFailNull) +TEST_P(TDMHwcWindow, SetInfoFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_info info = { 0 }; error = tdm_hwc_window_set_info(NULL, &info); @@ -365,85 +247,102 @@ TEST_F(TDMHwcWindow, SetInfoFailNull) ASSERT_NE(TDM_ERROR_NONE, error); } } -TEST_F(TDMHwcWindow, SetInfoSuccessful) + +TEST_P(TDMHwcWindow, SetInfoSuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_info info = { 0 }; - for (int i = 0; i < hwc_count; i++) { - error = tdm_hwc_window_set_info(hwc_wins[i], &info); + for (int w = 0; w < hwc_count; w++) { + error = tdm_hwc_window_set_info(hwc_wins[w], &info); ASSERT_EQ(TDM_ERROR_NONE, error); } } /* tdm_error tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer); */ -TEST_F(TDMHwcWindow, SetBufferFailNull) +TEST_P(TDMHwcWindow, SetBufferFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + error = tdm_hwc_window_set_buffer(NULL, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, SetBufferSuccessful) +TEST_P(TDMHwcWindow, SetBufferSuccessful) { - for (int i = 0; i < hwc_count; i++) { + TDM_UT_SKIP_FLAG(has_outputs); + + for (int w = 0; w < hwc_count; w++) { tbm_surface_h buff = tbm_surface_create(256, 256, TBM_FORMAT_ARGB8888); /* test: set*/ - error = tdm_hwc_window_set_buffer(hwc_wins[i], buff); + error = tdm_hwc_window_set_buffer(hwc_wins[w], buff); tbm_surface_destroy(buff); ASSERT_EQ(TDM_ERROR_NONE, error); /* test: reset*/ - error = tdm_hwc_window_set_buffer(hwc_wins[i], NULL); + error = tdm_hwc_window_set_buffer(hwc_wins[w], NULL); ASSERT_EQ(TDM_ERROR_NONE, error); } } /* tdm_error tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags); */ -TEST_F(TDMHwcWindow, SetFlagsFailNull) +TEST_P(TDMHwcWindow, SetFlagsFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; error = tdm_hwc_window_set_flags(NULL, flag); ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, SetFlagsSuccessful) +TEST_P(TDMHwcWindow, SetFlagsSuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; - for (int i = 0; i < hwc_count; i++) { + for (int w = 0; w < hwc_count; w++) { - error = tdm_hwc_window_set_flags(hwc_wins[i], flag); + error = tdm_hwc_window_set_flags(hwc_wins[w], flag); ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } } /* tdm_error tdm_hwc_window_unset_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags); */ -TEST_F(TDMHwcWindow, UnsetFlagsFailNull) +TEST_P(TDMHwcWindow, UnsetFlagsFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; error = tdm_hwc_window_unset_flags(NULL, flag); ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, UnsetFlagsSuccessful) +TEST_P(TDMHwcWindow, UnsetFlagsSuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; - for (int i = 0; i < hwc_count; i++) { + for (int w = 0; w < hwc_count; w++) { - error = tdm_hwc_window_unset_flags(hwc_wins[i], flag); + error = tdm_hwc_window_unset_flags(hwc_wins[w], flag); ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } } /* tdm_error tdm_hwc_window_video_get_capability(tdm_hwc_window *hwc_window, tdm_hwc_window_video_capability *video_capability); */ -TEST_F(TDMHwcWindow, VideoGetCapabilityFailNull) +TEST_P(TDMHwcWindow, VideoGetCapabilityFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_video_capability video_capability; error = tdm_hwc_window_video_get_capability(NULL, &video_capability); @@ -456,13 +355,15 @@ TEST_F(TDMHwcWindow, VideoGetCapabilityFailNull) } -TEST_F(TDMHwcWindow, VideoGetCapabilitySuccessful) +TEST_P(TDMHwcWindow, VideoGetCapabilitySuccessful) { + TDM_UT_SKIP_FLAG(has_outputs); + tdm_hwc_window_video_capability video_capability; - for (int i = 0; i < hwc_count; i++) { + for (int w = 0; w < hwc_count; w++) { /* hwc_window with TDM_COMPOSITION_CLIENT dosn't support tdm_hwc_window_video_get_capability()*/ - error = tdm_hwc_window_video_get_capability(hwc_wins[i], &video_capability); + error = tdm_hwc_window_video_get_capability(hwc_wins[w], &video_capability); ASSERT_NE(TDM_ERROR_NONE, error); if (video_hwc_win != NULL) { @@ -474,8 +375,10 @@ TEST_F(TDMHwcWindow, VideoGetCapabilitySuccessful) /* tdm_hwc_window_video_get_available_properties() */ -TEST_F(TDMHwcWindow, GetAvailablePropertiesFailNullWin) +TEST_P(TDMHwcWindow, GetAvailablePropertiesFailNullWin) { + TDM_UT_SKIP_FLAG(has_outputs); + TDM_UT_SKIP_FLAG(video_hwc_win != NULL); const tdm_prop *props; int count; @@ -490,8 +393,10 @@ TEST_F(TDMHwcWindow, GetAvailablePropertiesFailNullWin) ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, GetAvailablePropertiesSuccess) +TEST_P(TDMHwcWindow, GetAvailablePropertiesSuccess) { + TDM_UT_SKIP_FLAG(has_outputs); + TDM_UT_SKIP_FLAG(video_hwc_win != NULL); const tdm_prop *props; @@ -502,8 +407,9 @@ TEST_F(TDMHwcWindow, GetAvailablePropertiesSuccess) } /* tdm_hwc_window_video_get_property() */ -TEST_F(TDMHwcWindow, GetPropertyFailNull) +TEST_P(TDMHwcWindow, GetPropertyFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); TDM_UT_SKIP_FLAG(video_hwc_win != NULL); tdm_value value; @@ -516,8 +422,9 @@ TEST_F(TDMHwcWindow, GetPropertyFailNull) ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, GetPropertyFailWrongId) +TEST_P(TDMHwcWindow, GetPropertyFailWrongId) { + TDM_UT_SKIP_FLAG(has_outputs); TDM_UT_SKIP_FLAG(video_hwc_win != NULL); tdm_value value; @@ -528,9 +435,11 @@ TEST_F(TDMHwcWindow, GetPropertyFailWrongId) } /* tdm_hwc_window_video_set_property() */ -TEST_F(TDMHwcWindow, SetPropertyFailNull) +TEST_P(TDMHwcWindow, SetPropertyFailNull) { + TDM_UT_SKIP_FLAG(has_outputs); TDM_UT_SKIP_FLAG(video_hwc_win != NULL); + tdm_value value; int id = 1; @@ -538,8 +447,9 @@ TEST_F(TDMHwcWindow, SetPropertyFailNull) ASSERT_NE(TDM_ERROR_NONE, error); } -TEST_F(TDMHwcWindow, SetPropertyFailWrongId) +TEST_P(TDMHwcWindow, SetPropertyFailWrongId) { + TDM_UT_SKIP_FLAG(has_outputs); TDM_UT_SKIP_FLAG(video_hwc_win != NULL); tdm_value value; @@ -549,4 +459,7 @@ TEST_F(TDMHwcWindow, SetPropertyFailWrongId) ASSERT_NE(TDM_ERROR_NONE, error); } +INSTANTIATE_TEST_CASE_P(TDMHwcWindowParams, + TDMHwcWindow, + Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE))); #endif -- 2.7.4 From bdb174af619e1150c4c23e81b096fc3ce6b850b5 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 2 Mar 2018 16:06:07 +0900 Subject: [PATCH 07/16] add tdm_client_vblank_is_waiting Change-Id: I27df05723f0544c6f063a722100b6ecdbec6c944 --- client/tdm_client.c | 12 ++++++++++++ client/tdm_client.h | 8 ++++++++ 2 files changed, 20 insertions(+) diff --git a/client/tdm_client.c b/client/tdm_client.c index 4c38190..e71c691 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -1467,3 +1467,15 @@ tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, /* LCOV_EXCL_STOP */ } + +unsigned int +tdm_client_vblank_is_waiting(tdm_client_vblank *vblank) +{ + tdm_private_client_vblank *private_vblank; + + TDM_RETURN_VAL_IF_FAIL(vblank != NULL, 0); + + private_vblank = vblank; + + return (LIST_LENGTH(&private_vblank->wait_list) > 0) ? 1 : 0; +} diff --git a/client/tdm_client.h b/client/tdm_client.h index a96e4d4..4ef687b 100644 --- a/client/tdm_client.h +++ b/client/tdm_client.h @@ -409,6 +409,14 @@ tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_cli tdm_error tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence, tdm_client_vblank_handler func, void *user_data); +/** + * @brief Check if the client vblank object is waiting a vblank event + * @param[in] vblank The client vblank object + * @return 1 if waiting. 0 if not waiting. + */ +unsigned int +tdm_client_vblank_is_waiting(tdm_client_vblank *vblank); + #ifdef __cplusplus } #endif -- 2.7.4 From 65a8648ffaca491aa4d16640f1633f5f0cd0b07a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 2 Mar 2018 16:38:27 +0900 Subject: [PATCH 08/16] client: add tdm_client_handle_events_timeout Change-Id: Ifebfbe10670f7f8af366e26c8ea8e172f024d6a1 --- client/tdm_client.c | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++++ client/tdm_client.h | 12 ++++++++ include/tdm_common.h | 1 + 3 files changed, 98 insertions(+) diff --git a/client/tdm_client.c b/client/tdm_client.c index e71c691..84b4c07 100644 --- a/client/tdm_client.c +++ b/client/tdm_client.c @@ -42,6 +42,7 @@ #include #include #include +#include #include @@ -570,6 +571,90 @@ tdm_client_handle_events(tdm_client *client) /* LCOV_EXCL_STOP */ } +static int +_tdm_client_poll(struct wl_display *display, short int events, int timeout) +{ + int ret; + struct pollfd pfd[1]; + + pfd[0].fd = wl_display_get_fd(display); + pfd[0].events = events; + do { + ret = poll(pfd, 1, timeout); + } while (ret == -1 && errno == EINTR); + + return ret; +} + +static tdm_error +_tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout) +{ + int ret; + struct wl_display *display = private_client->display; + + if (wl_display_prepare_read(display) == -1) + return wl_display_dispatch_pending(display); + + while (true) { + ret = wl_display_flush(display); + + if (ret != -1 || errno != EAGAIN) + break; + + if (_tdm_client_poll(display, POLLOUT, -1) == -1) { + wl_display_cancel_read(display); + TDM_ERR("_tdm_client_poll failed"); + return TDM_ERROR_OPERATION_FAILED; + } + } + + /* Don't stop if flushing hits an EPIPE; continue so we can read any + * protocol error that may have triggered it. */ + if (ret < 0 && errno != EPIPE) { + TDM_ERR("ret(%d) errno(%d)", ret, errno); + wl_display_cancel_read(display); + return TDM_ERROR_OPERATION_FAILED; + } + + ret = _tdm_client_poll(display, POLLIN, timeout); + if (ret <= 0) { + wl_display_cancel_read(display); + if (ret == 0) { + TDM_ERR("_tdm_client_poll timeout."); + return TDM_ERROR_TIMEOUT; + } else { + TDM_ERR("_tdm_client_poll failed. (ret:%d)", ret); + return TDM_ERROR_OPERATION_FAILED; + } + } + + if (wl_display_read_events(display) == -1) { + TDM_ERR("wl_display_read_events failed"); + return TDM_ERROR_OPERATION_FAILED; + } + + ret = wl_display_dispatch_pending(display); + + if (ret < 0) { + TDM_ERR("_tdm_client_dispatch_timeout failed"); + return TDM_ERROR_OPERATION_FAILED; + } + + return TDM_ERROR_NONE; +} + +tdm_error +tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout) +{ + tdm_private_client *private_client; + + TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER); + + private_client = (tdm_private_client*)client; + + return _tdm_client_dispatch_timeout(private_client, ms_timeout); +} + typedef struct _tdm_client_vblank_temp { tdm_client_vblank_handler2 func; void *user_data; diff --git a/client/tdm_client.h b/client/tdm_client.h index 4ef687b..2b9dc1e 100644 --- a/client/tdm_client.h +++ b/client/tdm_client.h @@ -117,6 +117,18 @@ tdm_error tdm_client_handle_events(tdm_client *client); /** + * @brief Handle the events of the given file descriptor with millisecond timeout + * @details + * -1: infinite. 0: return immediately. Otherwise, waiting for ms_timeout milliseconds. + * @param[in] client A TDM client object + * @param[in] ms_timeout timeout value. + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @see #tdm_client_get_fd + */ +tdm_error +tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout); + +/** * @brief @b Deprecated. Wait for VBLANK. * @deprecated * @details After interval vblanks, a client vblank handler will be called. diff --git a/include/tdm_common.h b/include/tdm_common.h index 4c264ed..db7e087 100644 --- a/include/tdm_common.h +++ b/include/tdm_common.h @@ -69,6 +69,7 @@ typedef enum { TDM_ERROR_DPMS_OFF = -10, /**< dpms off */ TDM_ERROR_OUTPUT_DISCONNECTED = -11, /**< output disconnected */ TDM_ERROR_PROTOCOL_ERROR = -12, /**< protocol error */ + TDM_ERROR_TIMEOUT = -13, /**< timeout */ } tdm_error; /** -- 2.7.4 From f85ee3f925ce5175638d59fa0324e7f590746668 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 28 Feb 2018 14:47:01 +0900 Subject: [PATCH 09/16] log: remove unused code Change-Id: Id0683906617148ed05423561c3bf5987ad592f37 --- common/tdm_log.c | 15 ++++++--------- include/tdm_log.h | 1 - utests/src/ut_tdm_log.cpp | 4 ---- 3 files changed, 6 insertions(+), 14 deletions(-) diff --git a/common/tdm_log.c b/common/tdm_log.c index 3f6b560..aa3d182 100644 --- a/common/tdm_log.c +++ b/common/tdm_log.c @@ -87,23 +87,20 @@ tdm_log_enable_dlog(unsigned int enable) } EXTERN void -tdm_log_enable_debug(unsigned int enable) -{ - if (enable) - tdm_log_debug_level = TDM_LOG_LEVEL_DBG; - else - tdm_log_debug_level = TDM_LOG_LEVEL_INFO; -} - -EXTERN void tdm_log_set_debug_level(int level) { + const char *str = getenv("TDM_DEBUG_LEVEL"); + if (str) + level = str[0] - '0'; tdm_log_debug_level = level; } EXTERN void tdm_log_set_assert_level(int level) { + const char *str = getenv("TDM_ASSERT_LEVEL"); + if (str) + level = str[0] - '0'; assert_level = level; } diff --git a/include/tdm_log.h b/include/tdm_log.h index b653aa2..5a9fb65 100644 --- a/include/tdm_log.h +++ b/include/tdm_log.h @@ -66,7 +66,6 @@ enum { void tdm_log_enable_color(unsigned int enable); void tdm_log_enable_dlog(unsigned int enable); -void tdm_log_enable_debug(unsigned int enable); void tdm_log_set_debug_level(int level); void tdm_log_set_assert_level(int level); void tdm_log_set_path(const char *path); diff --git a/utests/src/ut_tdm_log.cpp b/utests/src/ut_tdm_log.cpp index 2d4e245..64f6154 100644 --- a/utests/src/ut_tdm_log.cpp +++ b/utests/src/ut_tdm_log.cpp @@ -36,7 +36,6 @@ TEST(TDMLog, logPrintf) { tdm_log_enable_color(1); tdm_log_enable_dlog(0); - tdm_log_enable_debug(1); tdm_log_set_debug_level(2); tdm_log_set_path("/tmp/tdm.log"); tdm_log_print(TDM_LOG_LEVEL_ERR, "utest\n"); @@ -58,7 +57,6 @@ TEST(TDMLog, logDlogNone) { tdm_log_enable_color(0); tdm_log_enable_dlog(1); - tdm_log_enable_debug(0); tdm_log_set_debug_level(0); tdm_log_print(TDM_LOG_LEVEL_ERR, "utest"); tdm_log_print(TDM_LOG_LEVEL_WRN, "utest"); @@ -69,7 +67,6 @@ TEST(TDMLog, logDlogNone) TEST(TDMLog, logDlog) { tdm_log_enable_dlog(1); - tdm_log_enable_debug(1); tdm_log_print(TDM_LOG_LEVEL_ERR, "utest"); tdm_log_print(TDM_LOG_LEVEL_WRN, "utest"); tdm_log_print(TDM_LOG_LEVEL_INFO, "utest"); @@ -79,7 +76,6 @@ TEST(TDMLog, logDlog) TEST(TDMLog, logDlogNormal) { tdm_log_enable_dlog(1); - tdm_log_enable_debug(0); tdm_log_print(TDM_LOG_LEVEL_ERR, "utest"); tdm_log_print(TDM_LOG_LEVEL_WRN, "utest"); tdm_log_print(TDM_LOG_LEVEL_INFO, "utest"); -- 2.7.4 From 174dde585e9e9ad3f34af6160371c70e06ce090e Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 10:18:07 +0900 Subject: [PATCH 10/16] log: add tdm_log_print_stdout Change-Id: I9ee3b16818e868f75b7bb114182f293d94a278bc --- common/tdm_log.c | 54 ++++++++++++++++++++++++++++++++++++------------------ include/tdm_log.h | 2 ++ 2 files changed, 38 insertions(+), 18 deletions(-) diff --git a/common/tdm_log.c b/common/tdm_log.c index aa3d182..348ea99 100644 --- a/common/tdm_log.c +++ b/common/tdm_log.c @@ -147,20 +147,50 @@ tdm_log_set_path(const char *path) } } -EXTERN void -tdm_log_print(int level, const char *fmt, ...) +static void +_tdm_log_vprint_stdout(int level, const char *fmt, va_list ap) { - va_list arg; - if (!log_lock_init) { log_lock_init = 1; pthread_mutex_init(&log_lock, NULL); - } if (level > tdm_log_debug_level) return; + char *lvl_str[] = {"TDM_NON", "TDM_ERR", "TDM_WRN", "TDM_INF", "TDM_DBG"}; + char *color[] = {COLOR_RESET, COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_RESET}; + + pthread_mutex_lock(&log_lock); + + if (color_enable) + printf("%s", color[level]); + printf("[%s]", lvl_str[level]); + if (color_enable) + printf(COLOR_RESET); + vprintf(fmt, ap); + printf("\n"); + pthread_mutex_unlock(&log_lock); +} + + +EXTERN void +tdm_log_print_stdout(int level, const char *fmt, ...) +{ + va_list arg; + va_start(arg, fmt); + _tdm_log_vprint_stdout(level, fmt, arg); + va_end(arg); +} + +EXTERN void +tdm_log_print(int level, const char *fmt, ...) +{ + va_list arg; + + if (level > tdm_log_debug_level) + return; + if (dlog_enable) { log_priority dlog_prio; switch (level) { @@ -183,21 +213,9 @@ tdm_log_print(int level, const char *fmt, ...) __dlog_vprint(LOG_ID_SYSTEM, dlog_prio, LOG_TAG, fmt, arg); va_end(arg); } else { - char *lvl_str[] = {"TDM_NON", "TDM_ERR", "TDM_WRN", "TDM_INF", "TDM_DBG"}; - char *color[] = {COLOR_RESET, COLOR_RED, COLOR_YELLOW, COLOR_GREEN, COLOR_RESET}; - - pthread_mutex_lock(&log_lock); - - if (color_enable) - printf("%s", color[level]); - printf("[%s]", lvl_str[level]); - if (color_enable) - printf(COLOR_RESET); va_start(arg, fmt); - vprintf(fmt, arg); + _tdm_log_vprint_stdout(level, fmt, arg); va_end(arg); - printf("\n"); - pthread_mutex_unlock(&log_lock); } assert(level > assert_level); diff --git a/include/tdm_log.h b/include/tdm_log.h index 5a9fb65..e25f685 100644 --- a/include/tdm_log.h +++ b/include/tdm_log.h @@ -69,7 +69,9 @@ void tdm_log_enable_dlog(unsigned int enable); void tdm_log_set_debug_level(int level); void tdm_log_set_assert_level(int level); void tdm_log_set_path(const char *path); +void tdm_log_print_stdout(int level, const char *fmt, ...); void tdm_log_print(int level, const char *fmt, ...); + void tdm_log_reset(void); extern unsigned int tdm_log_debug_level; -- 2.7.4 From a1cca1d19c5d26aa9dfad12d88a27d0e16cdb606 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 10:19:25 +0900 Subject: [PATCH 11/16] backend: add checking mandatory functions Change-Id: Ib9262959482250f95e43f7016ece3bc96581dce6 --- src/tdm.c | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/tdm.c b/src/tdm.c index b904755..fca53dd 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -728,10 +728,20 @@ _tdm_display_check_backend_functions(tdm_private_module *private_module) /* below functions should be implemented in backend side */ TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_display->display_get_outputs, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_wait_vblank, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_vblank_handler, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_commit, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_commit_handler, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_mode, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_info, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_info, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_buffer, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_unset_buffer, TDM_ERROR_BAD_MODULE); ret = func_display->display_get_capability(private_module->bdata, &private_module->caps_display); if (ret != TDM_ERROR_NONE) { -- 2.7.4 From 6fff5569f6cd0ff43969a6a57ba841db6afabb92 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 10:20:54 +0900 Subject: [PATCH 12/16] output: correct buffer leak when calling tdm_output_commit without a handler Change-Id: I032d556d6cab02d5bed3076e91fe57ed745a6bd3 --- src/tdm_layer.c | 31 +++++++++++++++---------------- src/tdm_output.c | 3 +++ src/tdm_private.h | 2 ++ 3 files changed, 20 insertions(+), 16 deletions(-) diff --git a/src/tdm_layer.c b/src/tdm_layer.c index f37a948..b36f37f 100644 --- a/src/tdm_layer.c +++ b/src/tdm_layer.c @@ -71,7 +71,6 @@ private_output = private_layer->private_output; \ private_display = private_output->private_display -static void _tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer); static void _tdm_layer_cb_wait_vblank(tdm_vblank *vblank, tdm_error error, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data); static void _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data); @@ -347,8 +346,8 @@ _tdm_layer_dump_buffer(tdm_layer *layer, tbm_surface_h buffer) } /* LCOV_EXCL_STOP */ -static void -_tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer) +void +tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer) { tdm_private_display *private_display; @@ -380,7 +379,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) _tdm_layer_reset_pending_data(private_layer); if (private_layer->waiting_buffer) { - _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); + tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); private_layer->waiting_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) @@ -389,7 +388,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) } if (private_layer->committed_buffer) { - _tdm_layer_free_buffer(private_layer, private_layer->committed_buffer); + tdm_layer_free_buffer(private_layer, private_layer->committed_buffer); private_layer->committed_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) @@ -398,7 +397,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) } if (private_layer->showing_buffer) { - _tdm_layer_free_buffer(private_layer, private_layer->showing_buffer); + tdm_layer_free_buffer(private_layer, private_layer->showing_buffer); private_layer->showing_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) @@ -416,7 +415,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) { LIST_DEL(&lm->link); tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm); - _tdm_layer_free_buffer(private_layer, lm->committed_buffer); + tdm_layer_free_buffer(private_layer, lm->committed_buffer); free(lm); } @@ -429,7 +428,7 @@ _tdm_layer_free_all_buffers(tdm_private_layer *private_layer) LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &clone_list, link) { LIST_DEL(&lm->link); - _tdm_layer_free_buffer(private_layer, lm->committed_buffer); + tdm_layer_free_buffer(private_layer, lm->committed_buffer); free(lm); } @@ -598,7 +597,7 @@ tdm_layer_committed(tdm_private_layer *private_layer, tdm_private_layer_buffer * TDM_TRACE_ASYNC_END((intptr_t)private_layer, "[LAYER] %d", tbm_bo_export(bo)); } - _tdm_layer_free_buffer(private_layer, private_layer->showing_buffer); + tdm_layer_free_buffer(private_layer, private_layer->showing_buffer); } private_layer->showing_buffer = *committed_buffer; @@ -650,7 +649,7 @@ _tdm_layer_got_output_vblank(tdm_private_output *private_output, unsigned int se lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data); _pthread_mutex_lock(&private_display->lock); if (lm->committed_buffer) - _tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer); + tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer); free(lm); } @@ -704,7 +703,7 @@ wait_failed: if (lm->func) lm->func(lm->private_layer, sequence, tv_sec, tv_usec, lm->user_data); _pthread_mutex_lock(&private_display->lock); - _tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer); + tdm_layer_free_buffer(lm->private_layer, lm->committed_buffer); free(lm); } @@ -876,7 +875,7 @@ tdm_layer_commit_pending_data(tdm_private_layer *private_layer) if (ret == TDM_ERROR_NONE) { if (private_layer->waiting_buffer) - _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); + tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); private_layer->waiting_buffer = layer_buffer; private_layer->waiting_buffer->buffer = tdm_buffer_ref_backend(private_layer->pending_buffer); @@ -884,7 +883,7 @@ tdm_layer_commit_pending_data(tdm_private_layer *private_layer) TDM_INFO("layer(%p) waiting_buffer(%p)", private_layer, private_layer->waiting_buffer->buffer); } else - _tdm_layer_free_buffer(private_layer, layer_buffer); + tdm_layer_free_buffer(private_layer, layer_buffer); } done: @@ -1070,7 +1069,7 @@ tdm_layer_remove_commit_handler_internal(tdm_layer *layer, tdm_layer_commit_hand if (lm->func == func && lm->user_data == user_data) { LIST_DEL(&lm->link); tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm); - _tdm_layer_free_buffer(private_layer, lm->committed_buffer); + tdm_layer_free_buffer(private_layer, lm->committed_buffer); free(lm); break; } @@ -1080,7 +1079,7 @@ tdm_layer_remove_commit_handler_internal(tdm_layer *layer, tdm_layer_commit_hand if (lm->func == func && lm->user_data == user_data) { LIST_DEL(&lm->link); tdm_output_remove_commit_handler_internal(private_output, _tdm_layer_cb_output_commit, lm); - _tdm_layer_free_buffer(private_layer, lm->committed_buffer); + tdm_layer_free_buffer(private_layer, lm->committed_buffer); free(lm); break; } @@ -1223,7 +1222,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) } if (private_layer->waiting_buffer) { - _tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); + tdm_layer_free_buffer(private_layer, private_layer->waiting_buffer); private_layer->waiting_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) diff --git a/src/tdm_output.c b/src/tdm_output.c index f208dfe..03dcd45 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -1129,6 +1129,9 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl if (!private_layer->waiting_buffer) continue; + if (private_layer->committed_buffer) + tdm_layer_free_buffer(private_layer, private_layer->committed_buffer); + private_layer->committed_buffer = private_layer->waiting_buffer; private_layer->waiting_buffer = NULL; if (tdm_debug_module & TDM_DEBUG_BUFFER) diff --git a/src/tdm_private.h b/src/tdm_private.h index 4cb34e4..43c639c 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -147,6 +147,8 @@ tdm_error tdm_layer_set_buffer_internal(tdm_private_layer *private_layer, tbm_surface_h buffer); tdm_error tdm_layer_unset_buffer_internal(tdm_private_layer *private_layer); +void +tdm_layer_free_buffer(tdm_private_layer *private_layer, tdm_private_layer_buffer *layer_buffer); tdm_error tdm_vblank_init(tdm_display *dpy); -- 2.7.4 From 182bd92fc2e8a7b9e908a28283adcc600c64c875 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 10:21:19 +0900 Subject: [PATCH 13/16] output: add tdm_output_has_capture_capability Change-Id: Ida5763d36449c1bb7c2734e63bdbf25eb4b0d90b --- include/tdm.h | 9 +++++++++ src/tdm_output.c | 25 +++++++++++++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/include/tdm.h b/include/tdm.h index 19d30ba..bc1f0ef 100644 --- a/include/tdm.h +++ b/include/tdm.h @@ -548,6 +548,15 @@ tdm_error tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value); /** + * @brief Check if a output object has the capture capability + * @param[in] output A output object + * @param[out] has_capability 1: has the capability, 0: not has the capability + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ +tdm_error +tdm_output_has_capture_capability(tdm_output *output, unsigned int *has_capability); + +/** * @brief Create a capture object of a output object * @param[in] output A output object * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. diff --git a/src/tdm_output.c b/src/tdm_output.c index 03dcd45..15ebd81 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -1473,6 +1473,31 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value) return ret; } +EXTERN tdm_error +tdm_output_has_capture_capability(tdm_output *output, unsigned int *has_capability) +{ + tdm_private_module *private_module; + + OUTPUT_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(has_capability != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_output->private_module; + + if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) + *has_capability = 0; + else if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)) + *has_capability = 0; + else + *has_capability = 1; + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + EXTERN tdm_capture * tdm_output_create_capture(tdm_output *output, tdm_error *error) { -- 2.7.4 From 988dbaba7a2c25420eafa70734e22e1c49057686 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 10:14:55 +0900 Subject: [PATCH 14/16] utests: correct pointer type Change-Id: I557633d3d01b90c00005b8e1b51df0e2afc485d7 --- utests/src/ut_tdm_layer.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utests/src/ut_tdm_layer.cpp b/utests/src/ut_tdm_layer.cpp index a0713be..5b8042a 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/utests/src/ut_tdm_layer.cpp @@ -75,7 +75,7 @@ void TDMLayer::SetUp(void) ASSERT_TRUE(count > 0); layer_count += count; - layers = (tdm_layer**)realloc((void*)layers, sizeof(tdm_layer*) * layer_count); + layers = (tdm_layer**)realloc(layers, sizeof(tdm_layer*) * layer_count); ASSERT_TRUE(layers != NULL); for (int l = 0; l < count; l++) { -- 2.7.4 From 77461541c237f97f3b45a5db816fc8759d25aa75 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 7 Mar 2018 11:29:11 +0900 Subject: [PATCH 15/16] package version up to 1.16.0 Change-Id: I4c0c3ba7a7e7fc5ca7b8d618bc873e4d61df53dd --- configure.ac | 2 +- doc/tdm_doc.h | 2 +- packaging/libtdm.spec | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/configure.ac b/configure.ac index 04bf549..1829d04 100644 --- a/configure.ac +++ b/configure.ac @@ -1,7 +1,7 @@ AC_PREREQ([2.60]) m4_define([tdm_major_version], [1]) -m4_define([tdm_minor_version], [15]) +m4_define([tdm_minor_version], [16]) m4_define([tdm_micro_version], [0]) m4_define([tdm_version], [tdm_major_version.tdm_minor_version.tdm_micro_version]) diff --git a/doc/tdm_doc.h b/doc/tdm_doc.h index d11256f..b7e3529 100644 --- a/doc/tdm_doc.h +++ b/doc/tdm_doc.h @@ -39,7 +39,7 @@ /** * @mainpage TDM * @author Boram Park, boram1288.park@samsung.com - * @version 1.15.0 + * @version 1.16.0 * @par Introduction * TDM stands for Tizen Display Manager. It's the display HAL layer for tizen * display server. It offers the frontend APIs(@ref tdm.h) for a frontend user diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 9ca1257..2abebe3 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.15.1 +Version: 1.16.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From a5be69dc815078b1132eb3291d56cd7ddb85a412 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 15:39:18 +0900 Subject: [PATCH 16/16] output: add debugging log Change-Id: I0dd4ef4067e18706257619a1cfb2f6dea79f0657 --- src/tdm_output.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/tdm_output.c b/src/tdm_output.c index 15ebd81..b846354 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -766,6 +766,9 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, vblank_handler->sent_to_frontend = 1; + if (tdm_debug_module & TDM_DEBUG_COMMIT) + TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler); + ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); } -- 2.7.4