From b6d03eae459c5727ee489c75ccf5b99f2b86fcd4 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 27 Feb 2018 14:30:36 +0900 Subject: [PATCH 01/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 02/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 03/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 04/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 05/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 06/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 07/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 08/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 09/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 10/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 11/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 12/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 13/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 14/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 From 1ffe57e554823b255a379390e220eac050417e5a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 15:39:37 +0900 Subject: [PATCH 15/16] utests: add more tc Change-Id: I304f08c9f390acdfd4a7935be4a404afaa6e6c63 --- utests/src/ut_tdm_output.cpp | 22 ++++++++++++++++++++++ utests/src/ut_tdm_vblank.cpp | 27 +++++++++++++++++++++++++++ 2 files changed, 49 insertions(+) diff --git a/utests/src/ut_tdm_output.cpp b/utests/src/ut_tdm_output.cpp index 4556178..e543a55 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/utests/src/ut_tdm_output.cpp @@ -1334,6 +1334,28 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) } } +TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + for (int o = 0; o < output_count; o++) { + if (!ut_tdm_output_is_connected(outputs[o])) + continue; + + ASSERT_TRUE(ut_tdm_output_prepare(dpy, outputs[o]) == true); + + for (int t = 0; t < 10; t++) { + bool done = false; + + ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE); + if (t == 9) + ASSERT_TRUE(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + while(!done) + ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + } + } +} + TEST_P(TDMOutput, OutputRemoveVblankHandler) { TDM_UT_SKIP_FLAG(has_outputs); diff --git a/utests/src/ut_tdm_vblank.cpp b/utests/src/ut_tdm_vblank.cpp index a4d9f8b..3b3e8e3 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/utests/src/ut_tdm_vblank.cpp @@ -1126,6 +1126,33 @@ TEST_P(TDMVblank, VblankWaitDpmsOff) } } +TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) +{ + TDM_UT_SKIP_FLAG(has_outputs); + + ASSERT_TRUE(TestPrepareOutput() == true); + ASSERT_TRUE(TestCreateVblanks() == true); + + for (int v = 0; v < vblank_count; v++) { + unsigned int temp = 0; + tdm_error ret; + tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); + ASSERT_TRUE(ret == TDM_ERROR_NONE); + + if (!ut_tdm_output_is_connected(output)) + continue; + + ASSERT_TRUE(ut_tdm_output_unset(dpy, output) == true); + + ASSERT_TRUE(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp) == TDM_ERROR_NONE); + + ASSERT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); + + while (temp == 0) + ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE); + } +} + TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) { TDM_UT_SKIP_FLAG(has_outputs); -- 2.7.4 From 7941cfbc65a4abcdc1e9c45716e0561348b0ed2a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 8 Mar 2018 21:35:07 +0900 Subject: [PATCH 16/16] thread: checking waiting cb_type if waiting_cb_type != cb_type->type, send cb to other thread if needed. when a thread is waiting status, if other thread tries to send the same type cb as sync, we CAN'T handle it. So we'd better make assert it to find another solution. Change-Id: I06f92b2814a3a4e0d23d9d6df3c8b17526e1175f --- src/tdm_thread.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/tdm_thread.c b/src/tdm_thread.c index db910c2..ca59103 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -613,6 +613,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) struct list_head *list, *other_list; struct list_head call_list; static pid_t waiting_tid = 0; + static tdm_thread_cb_type waiting_cb_type = TDM_THREAD_CB_NONE; tdm_error ret; TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); @@ -626,6 +627,10 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) assert(find_funcs[cb_base->type] != NULL); + /* When there is the previous waiting sync call, the other type sync call CAN't be handlered */ + if (waiting_tid > 0 && cb_base->sync == 1) + assert(waiting_cb_type == cb_base->type); + if (!object) { object = find_funcs[cb_base->type](private_display, cb_base->object_stamp); if (!object) { @@ -670,7 +675,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) assert(LIST_IS_EMPTY(&call_list)); - if (waiting_tid == 0) { + if (waiting_tid == 0 || waiting_cb_type != cb_base->type) { LIST_FOR_EACH_ENTRY_SAFE(cb, hh, other_list, link) { if (cb->object != object || cb->cb_type != cb_base->type || @@ -686,6 +691,7 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) if (keep_private_thread) { if (cb_base->sync) { waiting_tid = 0; + waiting_cb_type = TDM_THREAD_CB_NONE; pthread_cond_signal(&keep_private_thread->event_cond); if (tdm_debug_module & TDM_DEBUG_THREAD) TDM_INFO("pthread broadcase"); @@ -712,6 +718,8 @@ tdm_thread_cb_call(void *object, tdm_thread_cb_base *cb_base) */ tdm_mutex_locked = 0; waiting_tid = caller_tid; + waiting_cb_type = cb_base->type; + pthread_cond_wait(&keep_private_thread->event_cond, &private_display->lock); tdm_mutex_locked = 1; } -- 2.7.4