From c5d34acb3cd217e269f9215b2fa64d8a7b4b55d6 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Fri, 6 Apr 2018 16:42:06 +0900 Subject: [PATCH 01/16] buffer: remove unuseful function the behavior of tdm_buffer_remove_release_handler_internal is not clear. even if commit is failed, the buffer release function seems to need to be called. Change-Id: Idbf92ea109272d5556680ed87212095126d8b1cf --- src/tdm_buffer.c | 20 -------------------- src/tdm_capture.c | 6 ------ src/tdm_pp.c | 8 -------- src/tdm_private.h | 2 -- 4 files changed, 36 deletions(-) diff --git a/src/tdm_buffer.c b/src/tdm_buffer.c index 81716b5..97857b4 100644 --- a/src/tdm_buffer.c +++ b/src/tdm_buffer.c @@ -170,26 +170,6 @@ tdm_buffer_remove_release_handler(tbm_surface_h buffer, } } -INTERN void -tdm_buffer_remove_release_handler_internal(tbm_surface_h buffer) -{ - tdm_buffer_info *buf_info; - tdm_buffer_func_info *func_info = NULL, *next = NULL; - - TDM_RETURN_IF_FAIL(buffer != NULL); - - buf_info = tdm_buffer_get_info(buffer); - TDM_RETURN_IF_FAIL(buf_info != NULL); - - LIST_FOR_EACH_ENTRY_SAFE(func_info, next, &buf_info->release_funcs, link) { - - LIST_DEL(&func_info->link); - free(func_info); - - return; - } -} - EXTERN tbm_surface_h tdm_buffer_ref_backend(tbm_surface_h buffer) { diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 4b58fbd..1fd5bb4 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -663,12 +663,6 @@ tdm_capture_commit(tdm_capture *capture) if (ret != TDM_ERROR_NONE) { /* LCOV_EXCL_START */ - /* Not to call the user release handler when failed. - * Do we have to call this function here really? - * User better use set_done_handler to know when pp is done. Using - * buffer_release_handler is not good. - */ - tdm_buffer_remove_release_handler_internal(b->buffer); _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); diff --git a/src/tdm_pp.c b/src/tdm_pp.c index 1a0e91e..a53531a 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -573,14 +573,6 @@ tdm_pp_commit(tdm_pp *pp) continue; if (ret != TDM_ERROR_NONE) { - /* Not to call the user release handler when failed. - * Do we have to call this function here really? - * User better use set_done_handler to know when pp is done. Using - * buffer_release_handler is not good. - */ - tdm_buffer_remove_release_handler_internal(b->src); - tdm_buffer_remove_release_handler_internal(b->dst); - _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->src); tdm_buffer_unref_backend(b->dst); diff --git a/src/tdm_private.h b/src/tdm_private.h index 40f9e79..22c984c 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -187,8 +187,6 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture); /* utility buffer functions for private */ tdm_buffer_info* tdm_buffer_get_info(tbm_surface_h buffer); -void -tdm_buffer_remove_release_handler_internal(tbm_surface_h buffer); /* event functions for private */ tdm_error -- 2.7.4 From 3ad3e82dc0bc043697fc72d34c5cf7d051b69af4 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 9 Apr 2018 20:43:57 +0900 Subject: [PATCH 02/16] common: remove unuseful variable Change-Id: I1f47f58fb65b5b18f08e64b790e11c4c195e1c32 --- src/tdm.c | 31 ++++++++++++------------------- 1 file changed, 12 insertions(+), 19 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index 15840f4..1a84fc0 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -477,19 +477,17 @@ tdm_display_update_output(tdm_private_module *private_module, return TDM_ERROR_NONE; } -static tdm_output ** +static void _tdm_display_set_main_first(tdm_output **outputs, int index) { tdm_output *output_tmp = NULL; if (index == 0) - return outputs; + return; output_tmp = outputs[0]; outputs[0] = outputs[index]; outputs[index] = output_tmp; - - return outputs; } static tdm_output ** @@ -497,7 +495,6 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) { tdm_func_display *func_display = &private_module->func_display; tdm_output **outputs = NULL; - tdm_output **new_outputs = NULL; tdm_output *output_dsi = NULL; tdm_output *output_lvds = NULL; tdm_output *output_hdmia = NULL; @@ -580,32 +577,28 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) if (output_connected_count == 0) { /* hdmi > dsi > lvds > else */ if (output_hdmia != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmia); + _tdm_display_set_main_first(outputs, index_hdmia); else if (output_hdmib != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmib); + _tdm_display_set_main_first(outputs, index_hdmib); else if (output_dsi != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_dsi); + _tdm_display_set_main_first(outputs, index_dsi); else if (output_lvds != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_lvds); - else - new_outputs = outputs; + _tdm_display_set_main_first(outputs, index_lvds); } else { /* (output_connected_count > 1) */ /* dsi > lvds > hdmi > else */ if (output_dsi != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_dsi); + _tdm_display_set_main_first(outputs, index_dsi); else if (output_lvds != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_lvds); + _tdm_display_set_main_first(outputs, index_lvds); else if (output_hdmia != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmia); + _tdm_display_set_main_first(outputs, index_hdmia); else if (output_hdmib != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmib); - else - new_outputs = outputs; + _tdm_display_set_main_first(outputs, index_hdmib); } - private_module->outputs = new_outputs; + private_module->outputs = outputs; - return new_outputs; + return outputs; failed_get_outputs: free(outputs); -- 2.7.4 From e3bf909bf70dabcee8bb28a68fdb75b1a93fc671 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 9 Apr 2018 20:44:18 +0900 Subject: [PATCH 03/16] common: fix syntax error Change-Id: Ib6c52268e151511ba4aef5f15a84ac2adcba993b --- src/tdm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tdm.c b/src/tdm.c index 1a84fc0..08a9136 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -883,7 +883,7 @@ static tdm_error _tdm_display_load_modules(tdm_private_display *private_display) { const char *module_names; - tdm_error ret = 0; + tdm_error ret = TDM_ERROR_NONE; char temp[TDM_PATH_LEN]; char *arg; char *end; -- 2.7.4 From d6ada65f4863702f6d7d5c1080b408e332fb8923 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 9 Apr 2018 21:15:59 +0900 Subject: [PATCH 04/16] common: remove unuseful condition output_get_capability can't be null at this function. checking null is already done in other function. Change-Id: I737ab197eba4763cc6afbfd65d8b8e8183c4a122 --- src/tdm.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/tdm.c b/src/tdm.c index 08a9136..be3d0bf 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -528,11 +528,6 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) tdm_caps_output caps; memset(&caps, 0, sizeof(tdm_caps_output)); - if (!func_output->output_get_capability) { - TDM_ERR("no output_get_capability()"); - goto failed_get_outputs; - } - ret = func_output->output_get_capability(outputs[i], &caps); if (ret != TDM_ERROR_NONE) { TDM_ERR("output_get_capability() failed"); -- 2.7.4 From 547570439aa623b2f46197c3362e65f0af93dec1 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 9 Apr 2018 21:18:37 +0900 Subject: [PATCH 05/16] display: find the correct output To find a primary output, we have to check the connection status first. If there is no connected output, this function will return the first output. Change-Id: If386dcabc6524ce81a1f08c87082342a259278f3 --- src/tdm_display.c | 38 +++++++++++++++++++++++++++++++++++--- 1 file changed, 35 insertions(+), 3 deletions(-) diff --git a/src/tdm_display.c b/src/tdm_display.c index 9f66167..45ccdf2 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -634,18 +634,50 @@ tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error) { tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; + tdm_private_output *mode_setted_output = NULL; + tdm_private_output *connected_output = NULL; + unsigned int find_primary = 0; DISPLAY_FUNC_ENTRY_ERROR(); - if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) { - return tdm_display_get_output(dpy, 0, error); - } + if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) + find_primary = 1; _pthread_mutex_lock(&private_display->lock); if (error) *error = TDM_ERROR_NONE; + if (find_primary) { + 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->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output) + connected_output = private_output; + else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output) + mode_setted_output = private_output; + } + } + + if (mode_setted_output) { + _pthread_mutex_unlock(&private_display->lock); + return mode_setted_output; + } + + if (connected_output) { + _pthread_mutex_unlock(&private_display->lock); + return connected_output; + } + + 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 == 0) { + _pthread_mutex_unlock(&private_display->lock); + return private_output; + } + } + } + } + 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)) -- 2.7.4 From ff24c59c2316df5e88162fb202df293873f60c17 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 11 Apr 2018 08:52:09 +0900 Subject: [PATCH 06/16] hwc: add omitted unlocks Change-Id: I7631a2a6d9549a5361a05de2ccdc3a65b0452b6c --- src/tdm_hwc_window.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 8ef8042..25692b3 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -462,6 +462,7 @@ tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler ret = tdm_layer_unset_buffer_internal(private_layer); if (ret != TDM_ERROR_NONE) { TDM_ERR("failed: layer set buffer(window)"); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -469,6 +470,7 @@ tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler &window_info); if (ret != TDM_ERROR_NONE) { TDM_ERR("failed: commit layer(window)"); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -476,12 +478,14 @@ tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler ret = tdm_layer_set_info_internal(private_layer, info_layer); if (ret != TDM_ERROR_NONE) { TDM_ERR("failed: layer set info(window)"); + _pthread_mutex_unlock(&private_display->lock); return ret; } hwc_window_commit_handler = calloc(1, sizeof(tdm_private_hwc_window_commit_handler)); if (!hwc_window_commit_handler) { TDM_ERR("failed: alloc memory"); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OUT_OF_MEMORY; } @@ -493,6 +497,7 @@ tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler if (ret != TDM_ERROR_NONE) { TDM_ERR("failed: commit layer(window)"); free(hwc_window_commit_handler); + _pthread_mutex_unlock(&private_display->lock); return ret; } -- 2.7.4 From 7590648039833576048af41891ca3eccc2ed57b9 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Wed, 11 Apr 2018 13:22:34 +0900 Subject: [PATCH 07/16] package version up to 1.16.13 Change-Id: Icacee006b6aad474889c50a0b615bd432db69e0c --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 493b7b7..c7855e4 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.12 +Version: 1.16.13 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 08707fc90dc3c6adccea7a958ed6a58604990aee Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Fri, 30 Mar 2018 20:08:55 +0900 Subject: [PATCH 08/16] hwc: redesign the hwc change the frontend apis for hwc change the backend apis for hwc remove the useless codes Change-Id: I7571dfb817140ebc25a3bbff77dffb7edae2ff35 --- include/tdm.h | 444 +++++++++++----------------- include/tdm_backend.h | 476 +++++++++++++----------------- include/tdm_common.h | 10 - include/tdm_types.h | 56 ++-- src/Makefile.am | 1 + src/tdm.c | 163 ++++++++--- src/tdm_backend.c | 71 ++--- src/tdm_hwc.c | 550 ++++++++++++++++++++++++++++++++++ src/tdm_hwc_window.c | 491 +++++++++---------------------- src/tdm_macro.h | 2 +- src/tdm_output.c | 615 +-------------------------------------- src/tdm_private.h | 17 +- src/tdm_private_types.h | 56 ++-- src/tdm_thread.c | 2 +- utests/Makefile.am | 2 - utests/src/ut_tdm_hwc_window.cpp | 159 ++-------- utests/src/ut_tdm_output_hwc.cpp | 142 ++++----- 17 files changed, 1377 insertions(+), 1880 deletions(-) create mode 100644 src/tdm_hwc.c diff --git a/include/tdm.h b/include/tdm.h index 0f9bf5d..7beccd0 100644 --- a/include/tdm.h +++ b/include/tdm.h @@ -567,199 +567,14 @@ tdm_capture * tdm_output_create_capture(tdm_output *output, tdm_error *error); /** - * @brief Creates a new window on the given display. + * @brief Get a hwc associated with a output object. * @param[in] output A output object * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A created window object - * @since 2.0.0 - */ -tdm_hwc_window * -tdm_output_hwc_create_window(tdm_output *output, tdm_error *error); - -/** - * @brief Creates a new video window on the given output. - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A created window object - * @since 2.0.0 - */ -tdm_hwc_window * -tdm_output_hwc_create_video_window(tdm_output *output, tdm_error *error); - -/** - * @brief Destroys the given window. - * @param[in] output A output object - * @param[in] window the pointer of the window to destroy - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window); - -/** - * @brief Set the client(relative to the TDM) target buffer - * @details Sets the buffer which will receive the output of client composition. - * Window marked as TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE - * will be composited into this buffer prior to the call to tdm_output_commit(), - * and windows not marked as TDM_COMPOSITION_CLIENT and - * TDM_COMPOSITION_DEVICE_CANDIDATE should be composited with this buffer by the - * device. - * - * The buffer handle provided may be null if no windows are being composited by - * the client. This must not result in an error (unless an invalid display - * handle is also provided). - * - * The damage parameter describes a buffer damage region as defined in the - * description of tdm_hwc_window_set_buffer_damage(). - * - * List of composited hwc_windows (hwc_windows which buffers are presented on #target_buffer) - * should be passed along with #target_buffer to allow tdm to make the smooth transition - * from a DEVICE type to a CLIENT type. - * - * Should be called before tdm_output_commit() if any of the layers are marked as - * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. If no layers are - * so marked, then it is not necessary to call this function. It is not necessary - * to call tdm_output_hwc_validate() after changing the target through this function. - * @param[in] output A output object - * @param[in] target_buffer The new target buffer - * @param[in] damage The buffer damage region - * @param[in] composited_wnds The array of composited hwc_wnds - * @param[in] num_wnds The size of #composited_wnds array - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage); - -/** - * @brief Unset the client(relative to the TDM) target buffer - * @details TODO - * @param[in] output A output object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_output_hwc_unset_client_target_buffer(tdm_output *output); - -/** - * @brief Commit changes for a target_window - * @details After all change of a window object are applied, a user commit handler - * will be called. - * @param[in] hwc_window A window object - * @param[in] func A user commit handler - * @param[in] user_data The user data - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ -tdm_error -tdm_output_hwc_commit_client_target_buffer(tdm_output *output, tdm_output_hwc_target_buffer_commit_handler func, void *user_data); - -/** - * @brief Validate the output - * @details Instructs the device to inspect all of the layer state and - * determine if there are any composition type changes necessary before - * presenting the output. Permitted changes are described in the definition - * of tdm_hwc_window_composition_t above. - * @param[in] output A output object - * @param[out] num_types The number of composition type changes required by - * the device; if greater than 0, the client must either set and validate new - * types, or call tdm_output_hwc_accept_changes() to accept the changes returned by - * tdm_output_hwc_get_changed_composition_types(); must be the same as the number of - * changes returned by tdm_output_hwc_get_changed_composition_types (see the - * declaration of that function for more information); pointer will be non-NULL - * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @return A hwc object * @since 2.0.0 */ -tdm_error -tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds, uint32_t num_wnds, - uint32_t *num_types); - -/** - * @brief Set the 'need to validate' handler for the 'output' - * - * @details During backend's work it may need to ask for the revalidation - * (make client (E20) do tdm_output_hwc_validate() again), so a 'hndl' will - * be called as such need happen. Only one handler per output is supported. - * - * @param[in] output The output object a hndl is going to be registered for. - * @param[in] hndl The handler which will be called on the 'need to validate' event. - * - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_output_hwc_set_need_validate_handler(tdm_output *output, - tdm_output_need_validate_handler hndl); - -/** - * @brief Get changed composition types - * @details Retrieves the windows for which the device requires a different - * composition type than had been set prior to the last call to tdm_output_hwc_validate(). - * The client will either update its state with these types and call - * tdm_output_hwc_accept_changes, or will set new types and attempt to validate the - * display again. - * windows and types may be NULL to retrieve the number of elements which - * will be returned. The number of elements returned must be the same as the - * value returned in num_types from the last call to tdm_output_hwc_validate(). - * @param[in] output A output object - * @param[out] num_elements If windows or types were NULL, the number of layers - * and types which would have been returned; if both were non-NULL, the - * number of elements returned in layers and types, which must not exceed - * the value stored in num_elements prior to the call; pointer will be - * non-NULL - * @param[in] output A output object - * @param[out] windows An array of windows - * @param[out] composition_types An array of composition types, each corresponding - * to an element of windows - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -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); - -/** - * @brief Accepts the changes required by the device - * @details Accepts the changes required by the device from the previous - * tdm_output_hwc_validate() call (which may be queried using - * tdm_output_get_chaged_composition_types()) and revalidates the display. This - * function is equivalent to requesting the changed types from - * tdm_output_get_chaged_composition_types(), setting those types on the - * corresponding windows, and then calling tdm_output_hwc_validate again. - * After this call it must be valid to present this display. Calling this after - * tdm_output_hwc_validate() returns 0 changes must succeed with TDM_ERROR_NONE, but - * should have no other effect. - * @param[in] output A output object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_output_hwc_accept_changes(tdm_output *output); - -/** - * @brief Get a target buffer queue - * @details Buffers from target buffer queue will receive the output of - * client composition. Window marked as TDM_COMPOSITION_CLIENT or - * TDM_COMPOSITION_DEVICE_CANDIDATE will be composited into this buffers - * prior to the call to tdm_output_commit(). - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A buffer queue - * @since 2.0.0 - */ -tbm_surface_queue_h -tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error); - -/** - * @brief Get the supported format array for video hwc windows of a output object. - * @param[in] output A output object - * @param[out] formats The available format array - * @param[out] count The count of formats - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ -tdm_error -tdm_output_hwc_get_video_supported_formats(tdm_layer *layer, const tbm_format **formats, - int *count); +tdm_hwc * +tdm_output_get_hwc(tdm_output *output, tdm_error *error); /** * @brief Get a output object of a layer object @@ -1000,6 +815,173 @@ tdm_error tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags); /** + * @brief Creates a new window on the given hwc. + * @param[in] hwc A hwc object + * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. + * @return A created window object + * @since 2.0.0 + */ +tdm_hwc_window * +tdm_hwc_create_window(tdm_hwc *hwc, tdm_error *error); + +/** + * @brief Get the supported format array for hwc windows of a hwc object. + * @param[in] hwc A output hwc + * @param[out] formats The available format array + * @param[out] count The count of formats + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ +tdm_error +tdm_hwc_get_supported_formats(tdm_hwc *hwc, const tbm_format **formats, int *count); + +/** + * @brief Get the available property array of a hwc object. + * @param[in] hwc A hwc + * @param[out] props The available property array + * @param[out] count The count of properties + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ +tdm_error +tdm_hwc_get_available_properties(tdm_hwc *hwc, const tdm_prop **props, int *count); + +/** + * @brief Get a target buffer queue + * @details Buffers from target buffer queue will receive the output of + * client composition. Window marked as TDM_COMPOSITION_CLIENT or + * TDM_COMPOSITION_DEVICE_CANDIDATE will be composited into this buffers + * prior to the call to tdm_output_commit(). + * @param[in] output A output object + * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. + * @return A buffer queue + * @since 2.0.0 + */ +tbm_surface_queue_h +tdm_hwc_get_client_target_buffer_queue(tdm_hwc *hwc, tdm_error *error); + +/** + * @brief Set the client(relative to the TDM) target buffer + * @details Sets the buffer which will receive the output of client composition. + * Window marked as TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE + * will be composited into this buffer prior to the call to tdm_output_commit(), + * and windows not marked as TDM_COMPOSITION_CLIENT and + * TDM_COMPOSITION_DEVICE_CANDIDATE should be composited with this buffer by the + * device. + * + * The buffer handle provided may be null if no windows are being composited by + * the client. This must not result in an error (unless an invalid display + * handle is also provided). + * + * The damage parameter describes a buffer damage region as defined in the + * description of tdm_hwc_window_set_buffer_damage(). + * + * List of composited hwc_windows (hwc_windows which buffers are presented on #target_buffer) + * should be passed along with #target_buffer to allow tdm to make the smooth transition + * from a DEVICE type to a CLIENT type. + * + * Should be called before tdm_output_commit() if any of the layers are marked as + * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. If no layers are + * so marked, then it is not necessary to call this function. It is not necessary + * to call tdm_hwc_validate() after changing the target through this function. + * @param[in] hwc A output hwc + * @param[in] target_buffer The new target buffer + * @param[in] damage The buffer damage region + * @param[in] composited_wnds The array of composited hwc_wnds + * @param[in] num_wnds The size of #composited_wnds array + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ +tdm_error +tdm_hwc_set_client_target_buffer(tdm_hwc *hwc, tbm_surface_h target_buffer, tdm_region damage); + +/** + * @brief Validate the output + * @details Instructs the device to inspect all of the layer state and + * determine if there are any composition type changes necessary before + * presenting the output. Permitted changes are described in the definition + * of tdm_hwc_window_composition_t above. + * @param[in] output A output object + * @param[out] num_types The number of composition type changes required by + * the device; if greater than 0, the client must either set and validate new + * types, or call tdm_hwc_accept_changes() to accept the changes returned by + * tdm_hwc_get_changed_composition_types(); must be the same as the number of + * changes returned by tdm_hwc_get_changed_composition_types (see the + * declaration of that function for more information); pointer will be non-NULL + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ +tdm_error +tdm_hwc_validate(tdm_hwc *hwc, tdm_hwc_window **composited_wnds, uint32_t num_wnds, + uint32_t *num_types); + +/** + * @brief Get changed composition types + * @details Retrieves the windows for which the device requires a different + * composition type than had been set prior to the last call to tdm_hwc_validate(). + * The client will either update its state with these types and call + * tdm_hwc_accept_changes, or will set new types and attempt to validate the + * display again. + * windows and types may be NULL to retrieve the number of elements which + * will be returned. The number of elements returned must be the same as the + * value returned in num_types from the last call to tdm_hwc_validate(). + * @param[in] output A output object + * @param[out] num_elements If windows or types were NULL, the number of layers + * and types which would have been returned; if both were non-NULL, the + * number of elements returned in layers and types, which must not exceed + * the value stored in num_elements prior to the call; pointer will be + * non-NULL + * @param[in] output A output object + * @param[out] windows An array of windows + * @param[out] composition_types An array of composition types, each corresponding + * to an element of windows + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ +tdm_error +tdm_hwc_get_changed_composition_types(tdm_hwc *hwc, uint32_t *num_elements, + tdm_hwc_window **hwc_window, + tdm_hwc_window_composition *composition_types); + +/** + * @brief Accepts the changes required by the device + * @details Accepts the changes required by the device from the previous + * tdm_hwc_validate() call (which may be queried using + * tdm_hwc_get_chaged_composition_types()) and revalidates the display. This + * function is equivalent to requesting the changed types from + * tdm_hwc_get_chaged_composition_types(), setting those types on the + * corresponding windows, and then calling tdm_hwc_validate again. + * After this call it must be valid to present this display. Calling this after + * tdm_hwc_validate() returns 0 changes must succeed with TDM_ERROR_NONE, but + * should have no other effect. + * @param[in] output A output object + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ +tdm_error +tdm_hwc_accept_changes(tdm_hwc *hwc); + +/** + * @brief Commit changes for a hwc + * @details After all change of a window object are applied, a user commit handler + * will be called. + * @param[in] hwc A hwc object + * @param[in] sync 0: asynchronous, 1:synchronous + * @param[in] func A user commit handler + * @param[in] user_data The user data + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ +tdm_error +tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_data); + +/** + * @brief Destroys the given window. + * @param[in] output A output object + * @param[in] window the pointer of the window to destroy + * @since 2.0.0 + */ +void +tdm_hwc_window_destroy(tdm_hwc_window *hwc_window); + +/** * @brief Get a buffer queue for the window object * @details These buffers are used to composite by hardware a client content in * the nocomp mode. @@ -1009,11 +991,11 @@ tdm_layer_get_buffer_flags(tdm_layer *layer, unsigned int *flags); * @since 2.0.0 */ tbm_surface_queue_h -tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); +tdm_hwc_window_get_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); /** * @brief Sets the desired composition type of the given window. - * @details During tdm_output_hwc_validate(), the device may request changes to + * @details During tdm_hwc_validate(), the device may request changes to * the composition types of any of the layers as described in the definition * of tdm_hwc_window_composition_t above. * @param[in] hwc_window A window object @@ -1047,7 +1029,7 @@ tdm_hwc_window_set_composition_type(tdm_hwc_window *hwc_window, * @since 2.0.0 */ tdm_error -tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region damage); +tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_region damage); /** * @brief Set the information to a window object @@ -1077,94 +1059,24 @@ tdm_error tdm_hwc_window_set_buffer(tdm_hwc_window *hwc_window, tbm_surface_h buffer); /** - * @brief Unset a TBM buffer to a window object - * @details A TBM buffer will be applied when the output object of a layer - * object is committed. - * @param[in] hwc_window A window object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @return #TDM_ERROR_BUSY if #hwc_window can't be updated right now, this - * can happen if #hwc_window is involved in the smooth transition from - * DEVICE to CLIENT, this shouldn't be interpreted like some critical error. - * @since 2.0.0 - */ -tdm_error -tdm_hwc_window_unset_buffer(tdm_hwc_window *hwc_window); - -/** - * @brief Set a flags to a window object - * @param[in] hwc_window A window object - * @param[in] flags A hwc_window flags - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags); - -/** - * @brief Unset a flags from a window object - * @param[in] hwc_window A window object - * @param[in] flags A hwc_window flags - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_hwc_window_unset_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags); - -/** - * @brief Commit changes for a window object - * @details After all change of a window object are applied, a user commit handler - * will be called. - * @param[in] hwc_window A window object - * @param[in] func A user commit handler - * @param[in] user_data The user data - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ -tdm_error -tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler func, void *user_data); - -/** - * @brief Get the available property array of a video hwc window object. - * @param[in] hwc window A video hwc window object - * @param[out] props The available property array - * @param[out] count The count of properties - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ -tdm_error -tdm_hwc_window_video_get_available_properties(tdm_hwc_window *hwc_window, - const tdm_prop **props, int *count); - -/** * @brief Get the property which has a given id. - * @param[in] hwc window A video hwc window object + * @param[in] hwc window A hwc window object * @param[in] id The property id * @param[out] value The value * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ tdm_error -tdm_hwc_window_video_get_property(tdm_hwc_window *hwc_window, uint32_t id, - tdm_value *value); +tdm_hwc_window_get_property(tdm_hwc_window *hwc_window, uint32_t id, tdm_value *value); /** * @brief Set the property which has a given id. - * @param[in] hwc window A video hwc window object + * @param[in] hwc window A hwc window object * @param[in] id The property id * @param[in] value The value * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ tdm_error -tdm_hwc_window_video_set_property(tdm_hwc_window *hwc_window, uint32_t id, - tdm_value value); - -/** - * @brief Get the window video capability - * @param[in] hwc_window A window object - * @param[out] video_capability A hwc window video capability - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ -tdm_error -tdm_hwc_window_video_get_capability(tdm_hwc_window *hwc_window, - tdm_hwc_window_video_capability *video_capability); +tdm_hwc_window_set_property(tdm_hwc_window *hwc_window, uint32_t id, tdm_value value); /** * @brief Destroy a pp object diff --git a/include/tdm_backend.h b/include/tdm_backend.h index 0416a90..d43d73c 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -541,176 +541,12 @@ typedef struct _tdm_func_output { tdm_error (*output_set_dpms_async)(tdm_output *output, tdm_output_dpms dpms_value); /** - * @brief Creates a new window on the given display. + * @brief Get a hwc object of a output object * @param[in] output A output object * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A created window object - * @since 2.0.0 - */ - tdm_hwc_window *(*output_hwc_create_window)(tdm_output *output, tdm_error *error); - - /** - * @brief Destroys the given window. - * @param[in] output A output object - * @param[in] window the pointer of the window to destroy - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ - tdm_error (*output_hwc_destroy_window)(tdm_output *output, tdm_hwc_window *hwc_window); - - /** - * @brief Set the client(relative to the TDM) target buffer - * @details Sets the buffer which will receive the output of client composition. - * Window marked as TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE - * will be composited into this buffer prior to the call to output_commit(), - * and windows not marked as TDM_COMPOSITION_CLIENT and - * TDM_COMPOSITION_DEVICE_CANDIDATE should be composited with this buffer by the - * device. - * - * The buffer handle provided may be null if no windows are being composited by - * the client. This must not result in an error (unless an invalid display - * handle is also provided). - * - * The damage parameter describes a buffer damage region as defined in the - * description of hwc_window_set_buffer_damage(). - * - * List of composited hwc_windows (hwc_windows which buffers are presented on #target_buffer) - * will be passed along with #target_buffer to allow tdm to make the smooth transition - * from a DEVICE type to a CLIENT type. - * - * Will be called before output_commit() if any of the layers are marked as - * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. If no layers are - * so marked, then it is not necessary to call this function. It is not necessary - * to call output_hwc_validate() after changing the target through this function. - * @param[in] output A output object - * @param[in] target The new target buffer - * @param[in] damage The buffer damage region - * @param[in] composited_wnds The array of composited hwc_wnds - * @param[in] num_wnds The size of #composited_wnds array - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ - tdm_error (*output_hwc_set_client_target_buffer)(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage); - - /** - * @brief Unset the client(relative to the TDM) target buffer - * @details TODO - * @param[in] output A output object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ - tdm_error (*output_hwc_unset_client_target_buffer)(tdm_output *output); - - /** - * @brief Get the layer associated with the client target buffer - * @details TODO: - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A layer object. - * @since 2.0.0 - */ - tdm_layer *(*output_hwc_get_client_target_buffer_layer)(tdm_output *output, tdm_error *error); - - /** - * @brief Get the buffer which is set to the client target buffer - * @details TODO: - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A layer object. - * @since 2.0.0 - */ - tbm_surface_h (*output_hwc_get_client_target_buffer)(tdm_output *output, tdm_error *error); - - /** - * @brief Validate the output - * @details Instructs the device to inspect all of the layer state and - * determine if there are any composition type changes necessary before - * presenting the output. Permitted changes are described in the definition - * of tdm_composition_t above. - * @param[in] output A output object - * @param[out] num_types The number of composition type changes required by - * the device; if greater than 0, the client must either set and validate new - * types, or call output_hwc_accept_changes() to accept the changes returned by - * output_hwc_get_changed_composition_types(); must be the same as the number of - * changes returned by output_hwc_get_changed_composition_types (see the - * declaration of that function for more information); pointer will be non-NULL - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ - tdm_error (*output_hwc_validate)(tdm_output *output, tdm_hwc_window **composited_wnds, uint32_t num_wnds, - uint32_t *num_types); - - /** - * @brief Get changed composition types - * @details Retrieves the windows for which the device requires a different - * composition type than had been set prior to the last call to output_hwc_validate(). - * The client will either update its state with these types and call - * output_hwc_accept_changes, or will set new types and attempt to validate the - * display again. - * layers and types may be NULL to retrieve the number of elements which - * will be returned. The number of elements returned must be the same as the - * value returned in num_types from the last call to output_hwc_validate(). - * @param[in] output A output object - * @param[out] num_elements If windows or types were NULL, the number of layers - * and types which would have been returned; if both were non-NULL, the - * number of elements returned in layers and types, which must not exceed - * the value stored in num_elements prior to the call; pointer will be - * non-NULL - * @param[out] windows An array of windows - * @param[out] composition_types An array of composition types, each - * corresponding to an element of windows - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 + * @return A hwc object */ - tdm_error (*output_hwc_get_changed_composition_types)(tdm_output *output, - uint32_t *num_elements, - tdm_hwc_window **hwc_window, - tdm_hwc_window_composition *composition_types); - /** - * @brief Accepts the changes required by the device - * @details Accepts the changes required by the device from the previous - * output_hwc_validate() call (which may be queried using - * output_get_chaged_composition_types()) and revalidates the display. This - * function is equivalent to requesting the changed types from - * output_get_chaged_composition_types(), setting those types on the - * corresponding windows, and then calling output_hwc_validate again. - * After this call it must be valid to present this display. Calling this after - * output_hwc_validate() returns 0 changes must succeed with TDM_ERROR_NONE, but - * should have no other effect. - * @param[in] output A output object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @since 2.0.0 - */ - tdm_error (*output_hwc_accept_changes)(tdm_output *output); - - /** - * @brief Get a target buffer queue - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A buffer queue - * @since 2.0.0 - */ - tbm_surface_queue_h (*output_hwc_get_target_buffer_queue)(tdm_output *output, - tdm_error *error); - - /** - * @brief Get the supported format array for video hwc windows of a output object. - * @param[in] output A output object - * @param[out] formats The available format array - * @param[out] count The count of formats - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ - tdm_error (*output_hwc_get_video_supported_formats)(tdm_layer *layer, - const tbm_format **formats, int *count); - - /** - * @brief Creates a new video window on the given output. - * @param[in] output A output object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A created window object. If the video abilities isn't accessed return NULL - * @since 2.0.0 - */ - tdm_hwc_window *(*output_hwc_create_video_window)(tdm_output *output, tdm_error *error); + tdm_hwc *(*output_get_hwc)(tdm_output *output, tdm_error *error); void (*reserved5)(void); void (*reserved6)(void); @@ -847,23 +683,190 @@ typedef struct _tdm_func_layer { void (*reserved7)(void); } tdm_func_layer; +typedef struct _tdm_func_hwc { + /** + * @brief Create a new window on the given hwc. + * @param[in] hwc A hwc object + * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. + * @return A created window object + * @since 2.0.0 + */ + tdm_hwc_window *(*hwc_create_window)(tdm_hwc *hwc, tdm_error *error); + + /** + * @brief Get the supported format array for the hwc windows of a hwc object. + * @param[in] hwc A hwc object + * @param[out] formats The available format array + * @param[out] count The count of formats + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ + tdm_error (*hwc_get_supported_formats)(tdm_hwc *hwc, const tbm_format **formats, + int *count); + + + /** + * @brief Get the available property array of a hwc object. + * @param[in] hwc A hwc object + * @param[out] props The available property array + * @param[out] count The count of properties + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ + tdm_error (*hwc_get_available_properties)(tdm_hwc *hwc, const tdm_prop **props, + int *count); + + /** + * @brief Get a target buffer queue + * @param[in] hwc A hwc object + * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. + * @return A buffer queue + * @since 2.0.0 + */ + tbm_surface_queue_h (*hwc_get_client_target_buffer_queue)(tdm_hwc *hwc, + tdm_error *error); + + /** + * @brief Set the client(relative to the TDM) target buffer + * @details Sets the buffer which will receive the hwc of client composition. + * Window marked as TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE + * will be composited into this buffer prior to the call to hwc_commit(), + * and windows not marked as TDM_COMPOSITION_CLIENT and + * TDM_COMPOSITION_DEVICE_CANDIDATE should be composited with this buffer by the + * device. + * + * The buffer handle provided may be null if no windows are being composited by + * the client. This must not result in an error (unless an invalid display + * handle is also provided). + * + * The damage parameter describes a buffer damage region as defined in the + * description of hwc_window_set_buffer_damage(). + * + * Will be called before hwc_commit() if any of the layers are marked as + * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. If no layers are + * so marked, then it is not necessary to call this function. It is not necessary + * to call hwc_validate() after changing the target through this function. + * @param[in] hwc A hwc object + * @param[in] target The new target buffer + * @param[in] damage The buffer damage region + * @param[in] composited_wnds The array of composited hwc_wnds + * @param[in] num_wnds The size of #composited_wnds array + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ + tdm_error (*hwc_set_client_target_buffer)(tdm_hwc *hwc, + tbm_surface_h target_buffer, + tdm_region damage); + + /** + * @brief Validate the hwc + * @details Instructs the device to inspect all of the layer state and + * determine if there are any composition type changes necessary before + * presenting the hwc. Permitted changes are described in the definition + * of tdm_composition_t above. + * @param[in] hwc A hwc object + * @param[out] num_types The number of composition type changes required by + * the device; if greater than 0, the client must either set and validate new + * types, or call hwc_accept_changes() to accept the changes returned by + * hwc_get_changed_composition_types(); must be the same as the number of + * changes returned by hwc_get_changed_composition_types (see the + * declaration of that function for more information); pointer will be non-NULL + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ + tdm_error (*hwc_validate)(tdm_hwc *hwc, tdm_hwc_window **composited_wnds, + uint32_t num_wnds, uint32_t *num_types); + + /** + * @brief Get changed composition types + * @details Retrieves the windows for which the device requires a different + * composition type than had been set prior to the last call to hwc_validate(). + * The client will either update its state with these types and call + * hwc_accept_changes, or will set new types and attempt to validate the + * display again. + * layers and types may be NULL to retrieve the number of elements which + * will be returned. The number of elements returned must be the same as the + * value returned in num_types from the last call to hwc_validate(). + * @param[in] hwc A hwc object + * @param[out] num_elements If windows or types were NULL, the number of layers + * and types which would have been returned; if both were non-NULL, the + * number of elements returned in layers and types, which must not exceed + * the value stored in num_elements prior to the call; pointer will be + * non-NULL + * @param[out] windows An array of windows + * @param[out] composition_types An array of composition types, each + * corresponding to an element of windows + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ + tdm_error (*hwc_get_changed_composition_types)(tdm_hwc *hwc, uint32_t *num_elements, + tdm_hwc_window **hwc_window, + tdm_hwc_window_composition *composition_types); + /** + * @brief Accepts the changes required by the device + * @details Accepts the changes required by the device from the previous + * hwc_validate() call (which may be queried using + * hwc_get_chaged_composition_types()) and revalidates the display. This + * function is equivalent to requesting the changed types from + * hwc_get_chaged_composition_types(), setting those types on the + * corresponding windows, and then calling hwc_validate again. + * After this call it must be valid to present this display. Calling this after + * hwc_validate() returns 0 changes must succeed with TDM_ERROR_NONE, but + * should have no other effect. + * @param[in] hwc A hwc object + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @since 2.0.0 + */ + tdm_error (*hwc_accept_changes)(tdm_hwc *hwc); + + /** + * @brief Commit changes for a output object + * @param[in] hwc A hwc object + * @param[in] sync 0: asynchronous, 1:synchronous + * @param[in] user_data The user data + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @see hwc_set_commit_handler, tdm_hwc_commit_handler + * @remark + * When this function is called, a backend module @b SHOULD apply the all + * changes of the given output object to screen as well as the layer changes + * of this output. + * If this function returns TDM_ERROR_NONE, a backend module @b SHOULD call + * a user commit handler with the user data of this function after all + * changes of the given output object are applied. + */ + tdm_error (*hwc_commit)(tdm_hwc *hwc, int sync, void *user_data); + + /** + * @brief Set a user commit handler + * @param[in] hwc A hwc object + * @param[in] func A user commit handler + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + */ + tdm_error (*hwc_set_commit_handler)(tdm_output *hwc, tdm_hwc_commit_handler func); +} tdm_func_hwc; + /** * @brief The window functions for a backend module. * @since 2.0.0 */ -typedef struct _tdm_func_window { +typedef struct _tdm_func_hwc_window { + /** + * @brief Destroys the given window. + * @param[in] window the pointer of the window to destroy + * @since 2.0.0 + */ + void (*hwc_window_destroy)(tdm_hwc_window *hwc_window); + /** * @brief Get a buffer queue for the window object * @param[in] hwc_window A window object * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. * @return A buffer queue */ - tbm_surface_queue_h (*hwc_window_get_tbm_buffer_queue)(tdm_hwc_window *hwc_window, - tdm_error *error); + tbm_surface_queue_h (*hwc_window_get_buffer_queue)(tdm_hwc_window *hwc_window, + tdm_error *error); /** * @brief Sets the desired composition type of the given window. - * @details During output_hwc_validate(), the device may request changes to + * @details During hwc_validate(), the device may request changes to * the composition types of any of the layers as described in the definition * of tdm_hwc_window_composition_t above. * @param[in] hwc_window A window object @@ -877,7 +880,7 @@ typedef struct _tdm_func_window { * @brief Set the buffer damage * @details Provides the region of the source buffer which has been modified * since the last frame. This region does not need to be validated before - * calling output_commit(). + * calling hwc_commit(). * Once set through this function, the damage region remains the same until a * subsequent call to this function. * If damage.num_rects > 0, then it may be assumed that any portion of the source @@ -894,11 +897,11 @@ typedef struct _tdm_func_window { * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ tdm_error (*hwc_window_set_buffer_damage)(tdm_hwc_window *hwc_window, - tdm_hwc_region damage); + tdm_region damage); /** * @brief Set the information to a window object - * @details The information will be applied when the output object + * @details The information will be applied when the hwc object * of a layer object is committed. * @param[in] hwc_window A window object * @param[in] info The geometry information @@ -918,7 +921,7 @@ typedef struct _tdm_func_window { /** * @brief Set a TDM buffer to a window object - * @details A TDM buffer will be applied when the output object + * @details A TDM buffer will be applied when the hwc object * of a layer object is committed. * @param[in] hwc_window A window object * @param[in] buffer A TDM buffer @@ -932,104 +935,24 @@ typedef struct _tdm_func_window { tbm_surface_h buffer); /** - * @brief Unset a TDM buffer to a window object - * @details A TDM buffer will be applied when the output object - * of a layer object is committed. - * @param[in] hwc_window A window object - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * - * Implementation should return #TDM_ERROR_BUSY if #hwc_window can't - * be updated right now, this won't be interpreted like some critical - * error. - */ - tdm_error (*hwc_window_unset_buffer)(tdm_hwc_window *hwc_window); - - /** - * @brief Get a buffer which is set to a window object - * @details A TDM buffer will be applied when the output object - * of a layer object is committed. - * @param[in] hwc_window A window object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A buffer which is @b assigend to a window object - * - * Implementation should return #TDM_ERROR_BUSY if #hwc_window can't - * be updated right now, this won't be interpreted like some critical - * error. - */ - tbm_surface_h (*hwc_window_get_buffer)(tdm_hwc_window *hwc_window, - tdm_error *error); - - /** - * @brief Get a layer associated with a window object - * @param[in] hwc_window A window object - * @param[out] error #TDM_ERROR_NONE if success. Otherwise, error value. - * @return A layer which is @b assigend to a window object - * @remark - * A backend module @b SHOULD implement this function. The backend should - * return the tdm_layer assoicated with a hwc_window which must be assigend - * hw overlay.\n - */ - tdm_layer *(*hwc_window_get_layer)(tdm_hwc_window *hwc_window, - tdm_error *error); - - /** - * @brief Set a flags to a window object - * @param[in] hwc_window A window object - * @param[in] flags A hwc_window flags - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ - tdm_error (*hwc_window_set_flags)(tdm_hwc_window *hwc_window, - tdm_hwc_window_flag flags); - - /** - * @brief Unset a flags from a window object - * @param[in] hwc_window A window object - * @param[in] flags A hwc_window flags - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ - tdm_error (*hwc_window_unset_flags)(tdm_hwc_window *hwc_window, - tdm_hwc_window_flag flags); - - /** - * @brief Get the window video capability - * @param[in] hwc_window A window object - * @param[out] video_capability A hwc window video capability - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ - tdm_error (*hwc_window_video_get_capability)(tdm_hwc_window *hwc_window, - tdm_hwc_window_video_capability *video_capability); - - /** - * @brief Get the available property array of a video hwc window object. - * @param[in] hwc window A video hwc window object - * @param[out] props The available property array - * @param[out] count The count of properties + * @brief Set the property which has a given id. + * @param[in] hwc window A hwc window object + * @param[in] id The property id + * @param[in] value The value * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ - tdm_error (*hwc_window_video_get_available_properties)( - tdm_hwc_window *hwc_window, - const tdm_prop **props, int *count); + tdm_error (*hwc_window_set_property)(tdm_hwc_window *hwc_window, + uint32_t id, tdm_value value); /** * @brief Get the property which has a given id. - * @param[in] hwc window A video hwc window object + * @param[in] hwc window A hwc window object * @param[in] id The property id * @param[out] value The value * @return #TDM_ERROR_NONE if success. Otherwise, error value. */ - tdm_error (*hwc_window_video_get_property)(tdm_hwc_window *hwc_window, - uint32_t id, tdm_value *value); - - /** - * @brief Set the property which has a given id. - * @param[in] hwc window A video hwc window object - * @param[in] id The property id - * @param[in] value The value - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - */ - tdm_error (*hwc_window_video_set_property)(tdm_hwc_window *hwc_window, - uint32_t id, tdm_value value); - + tdm_error (*hwc_window_get_property)(tdm_hwc_window *hwc_window, + uint32_t id, tdm_value *value); } tdm_func_hwc_window; /** @@ -1443,16 +1366,27 @@ tdm_event_loop_source_timer_update(tdm_event_loop_source *source, unsigned int m void tdm_event_loop_source_remove(tdm_event_loop_source *source); +/** + * @brief Get the ini value with given key + * @details + * @param[in] key The given key + * @param[in] default_value The default value + * @return the value of given key if success. Otherwise, default_value. + * @see #tdm_config_get_string + */ +int +tdm_config_get_int(const char *key, int default_value); /** - * @brief Trigger a 'need to validate' event. - * @param[in] output The output the event should be triggered for. - * @note The global display lock has to be locked before the call to this function. - * @see #tdm_output_hwc_set_need_validate_handler - * @since 2.0.0 + * @brief Get the ini value with given key + * @details + * @param[in] key The given key + * @param[in] default_value The default value + * @return the value of given key if success. Otherwise, default_value. + * @see #tdm_config_get_int */ -tdm_error -tdm_backend_trigger_need_validate_event(tdm_output *output); +const char * +tdm_config_get_string(const char *key, const char *default_value); #ifdef __cplusplus } diff --git a/include/tdm_common.h b/include/tdm_common.h index ef5ee15..328f837 100644 --- a/include/tdm_common.h +++ b/include/tdm_common.h @@ -137,16 +137,6 @@ typedef enum { } tdm_layer_capability; /** - * @brief The hwc window capability enumeration - * @since 2.0.0 - */ -typedef enum { - TDM_HWC_WINDOW_VIDEO_CAPABILITY_SCALE = (1 << 1), /**< if a hwc window video has scale capability */ - TDM_HWC_WINDOW_VIDEO_CAPABILITY_TRANSFORM = (1 << 2), /**< if a hwc window video has transform capability */ - TDM_HWC_WINDOW_VIDEO_CAPABILITY_SCANOUT = (1 << 3), /**< if a hwc_window video allows a scanout buffer only */ -} tdm_hwc_window_video_capability; - -/** * @brief The pp capability enumeration * @details The scale, transform and CSC functionalities seem the default functions of PP. * If hardware device doesn't support one of them, we'd better let a developer know diff --git a/include/tdm_types.h b/include/tdm_types.h index 68f3096..32f544d 100644 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -115,6 +115,15 @@ typedef struct _tdm_info_layer { } tdm_info_layer; /** + * @brief The region structure + * @since 2.0.0 + */ +typedef struct _tdm_region { + unsigned int num_rects; + tdm_pos const *rects; +} tdm_region; + +/** * @brief The hwc window info structure * @since 2.0.0 */ @@ -124,11 +133,6 @@ typedef struct _tdm_hwc_window_info { tdm_transform transform; } tdm_hwc_window_info; -typedef struct _tdm_hwc_region { - unsigned int num_rects; - tdm_pos const *rects; -} tdm_hwc_region; - /** * @brief The pp info structre */ @@ -173,18 +177,18 @@ typedef enum { */ TDM_COMPOSITION_CLIENT = 1, - /** Set by the client before tdm_output_hwc_validate(). + /** Set by the client before tdm_hwc_validate(). * - * Upon tdm_output_hwc_validate(), the device may request a change from this type to + * Upon tdm_hwc_validate(), the device may request a change from this type to * TDM_COMPOSITION_DEVICE or TDM_COMPOSITION_CLIENT. */ TDM_COMPOSITION_DEVICE_CANDIDATE = 2, - /** Set by the HWC after tdm_output_hwc_validate(). + /** Set by the HWC after tdm_hwc_validate(). * * The device will handle the composition of this window through a hardware * overlay or other similar means. * - * Upon tdm_output_hwc_validate(), the device may request a change from this type to + * Upon tdm_hwc_validate(), the device may request a change from this type to * TDM_COMPOSITION_CLIENT or TDM_COMPOSITION_DEVICE_CANDIDATE. */ TDM_COMPOSITION_DEVICE = 3, @@ -192,9 +196,9 @@ typedef enum { * asynchronously through layer_set_cursor_position. If this functionality is not * supported on a layer that the client sets to TDM_COMPOSITION_CURSOR, the * device must request that the composition type of that layer is changed to - * TDM_COMPOSITION_CLIENT upon the next call to tdm_output_hwc_validate(). + * TDM_COMPOSITION_CLIENT upon the next call to tdm_hwc_validate(). * - * Upon tdm_output_hwc_validate(), the device may request a change from this type to + * Upon tdm_hwc_validate(), the device may request a change from this type to * either TDM_COMPOSITION_DEVICE or TDM_COMPOSITION_CLIENT. Changing to * TDM_COMPOSITION_DEVICE will prevent the use of layer_set_cursor_position but * still permit the device to composite the layer. */ @@ -236,7 +240,13 @@ typedef void tdm_output; typedef void tdm_layer; /** - * @brief The tdm window object + * @brief The tdm hwc object + * @since 2.0.0 + */ +typedef void tdm_hwc; + +/** + * @brief The tdm hwc window object * @since 2.0.0 */ typedef void tdm_hwc_window; @@ -290,20 +300,6 @@ typedef void (*tdm_layer_commit_handler)(tdm_layer *layer, unsigned int sequence void *user_data); /** - * @brief The hwc_window commit handler - */ -typedef void (*tdm_hwc_window_commit_handler)(tdm_hwc_window *hwc_window, unsigned int sequence, - unsigned int tv_sec, unsigned int tv_usec, - void *user_data); - -/** - * @brief The output target_buffer commit handler - */ -typedef void (*tdm_output_hwc_target_buffer_commit_handler)(tdm_output *output, unsigned int sequence, - unsigned int tv_sec, unsigned int tv_usec, - void *user_data); - -/** * @brief The done handler of a pp object */ typedef void (*tdm_pp_done_handler)(tdm_pp *pp, tbm_surface_h src, @@ -321,10 +317,12 @@ typedef void (*tdm_capture_done_handler)(tdm_capture *capture, typedef void (*tdm_vblank_create_handler)(tdm_vblank *vblank, void *user_data); /** - * @brief The 'need to validate' handler of an output object - * @since 2.0.0 + * @brief The hwc commit handler + * @see hwc_set_commit_handler() function of #tdm_func_hwc */ -typedef void (*tdm_output_need_validate_handler)(tdm_output *output); +typedef void (*tdm_hwc_commit_handler)(tdm_hwc *hwc, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, + void *user_data); #ifdef __cplusplus } diff --git a/src/Makefile.am b/src/Makefile.am index 7ec1cd4..f9616e4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -23,6 +23,7 @@ libtdm_la_SOURCES = \ tdm_display.c \ tdm_output.c \ tdm_layer.c \ + tdm_hwc.c \ tdm_hwc_window.c \ tdm_pp.c \ tdm_capture.c \ diff --git a/src/tdm.c b/src/tdm.c index be3d0bf..bc59c3c 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -97,6 +97,44 @@ tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp return NULL; } +tdm_private_hwc * +tdm_display_find_private_hwc(tdm_private_display *private_display, tdm_hwc *hwc_backend) +{ + tdm_private_module *private_module = NULL; + tdm_private_output *private_output = NULL; + tdm_private_hwc *private_hwc = NULL; + + 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->private_hwc) continue; + private_hwc = private_output->private_hwc; + if (private_hwc->hwc_backend == hwc_backend) + return private_hwc; + } + } + + return NULL; +} + +INTERN void * +tdm_display_find_hwc_stamp(tdm_private_display *private_display, double stamp) +{ + tdm_private_module *private_module = NULL; + tdm_private_output *private_output = NULL; + tdm_private_hwc *private_hwc = NULL; + + 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->private_hwc) continue; + private_hwc = private_output->private_hwc; + if (private_hwc->stamp == stamp) + return private_hwc; + } + } + + return NULL; +} + static void _tdm_display_destroy_caps_pp(tdm_caps_pp *caps_pp) { @@ -164,10 +202,12 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) { tdm_private_display *private_display = private_output->private_display; tdm_private_layer *l = NULL, *ll = NULL; + tdm_private_hwc *private_hwc = NULL; tdm_private_hwc_window *hw = NULL, *hww = NULL; tdm_private_capture *c = NULL, *cc = NULL; tdm_private_output_vblank_handler *v = NULL, *vv = NULL; tdm_private_output_commit_handler *om = NULL, *omm = NULL; + tdm_private_hwc_commit_handler *hm = NULL, *hmm = NULL; tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL; tdm_private_output_change_handler *h = NULL, *hh = NULL; @@ -186,9 +226,17 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) free(om); } - LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) { - LIST_DEL(&lm->link); - free(lm); + if (private_output->private_hwc) { + private_hwc = private_output->private_hwc; + LIST_FOR_EACH_ENTRY_SAFE(hm, hmm, &private_hwc->hwc_commit_handler_list, link) { + LIST_DEL(&hm->link); + free(hm); + } + } else { + LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) { + LIST_DEL(&lm->link); + free(lm); + } } LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) { @@ -218,21 +266,20 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) } LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link) - tdm_capture_destroy_internal(c); - - LIST_FOR_EACH_ENTRY_SAFE(hw, hww, &private_output->hwc_window_list, link) - tdm_hwc_window_destroy_internal(hw); - - LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link) - _tdm_display_destroy_private_layer(l); + tdm_capture_destroy_internal(c); + + if (private_output->private_hwc) { + private_hwc = private_output->private_hwc; + LIST_FOR_EACH_ENTRY_SAFE(hw, hww, &private_hwc->hwc_window_list, link) + tdm_hwc_window_destroy_internal(hw); + free(private_hwc); + } else { + LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link) + _tdm_display_destroy_private_layer(l); + } _tdm_display_destroy_caps_output(&private_output->caps); - tdm_thread_cb_remove(private_output, TDM_THREAD_CB_NEED_VALIDATE, NULL, - tdm_output_need_validate_handler_thread, NULL); - tdm_event_loop_source_remove(private_output->need_validate.event_source); - close(private_output->need_validate.event_fd); - /* when destroying output, vblank objects are also destroyed. vblank checks * if output object is valid. So delete the output's link at last. */ @@ -405,6 +452,8 @@ tdm_display_update_output(tdm_private_module *private_module, tdm_func_output *func_output = &private_module->func_output; tdm_private_output *private_output = NULL; tdm_layer **layers = NULL; + tdm_private_hwc *private_hwc = NULL; + tdm_hwc *hwc; int layer_count = 0, i; tdm_error ret; @@ -426,53 +475,82 @@ tdm_display_update_output(tdm_private_module *private_module, private_output->pipe = pipe; private_output->index = pipe; - LIST_INITHEAD(&private_output->layer_list); - LIST_INITHEAD(&private_output->hwc_window_list); LIST_INITHEAD(&private_output->capture_list); LIST_INITHEAD(&private_output->vblank_handler_list); LIST_INITHEAD(&private_output->output_commit_handler_list); - LIST_INITHEAD(&private_output->layer_commit_handler_list); LIST_INITHEAD(&private_output->pending_commit_handler_list); LIST_INITHEAD(&private_output->change_handler_list); - private_output->need_validate.event_fd = -1; - if (func_output->output_set_status_handler) { func_output->output_set_status_handler(private_output->output_backend, tdm_output_cb_status, private_output); private_output->regist_change_cb = 1; } - } - - /* need_new_caps will be true only in case of "disconnected -> connected" and "connected -> disconnected" - * because we have to get new modes. - */ - if (need_new_caps) { - _tdm_display_destroy_caps_output(&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); if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) private_output->current_mode = NULL; - } - layers = func_output->output_get_layers(output_backend, &layer_count, &ret); - if (ret != TDM_ERROR_NONE) { - free(layers); - return ret; + /* get the tdm_hwc object */ + if (private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) { + hwc = func_output->output_get_hwc(output_backend, &ret); + TDM_RETURN_VAL_IF_FAIL(hwc != NULL, ret); + + private_hwc = calloc(1, sizeof(tdm_private_hwc)); + TDM_RETURN_VAL_IF_FAIL(private_hwc != NULL, TDM_ERROR_OUT_OF_MEMORY); + + private_hwc->private_module = private_module; + private_hwc->private_output = private_output; + private_hwc->hwc_backend = hwc; + private_hwc->index = pipe; + private_hwc->stamp = tdm_helper_get_time(); + while (tdm_display_find_hwc_stamp(private_module->private_display, private_hwc->stamp)) + private_hwc->stamp++; + + LIST_INITHEAD(&private_hwc->hwc_window_list); + LIST_INITHEAD(&private_hwc->hwc_commit_handler_list); + + private_output->private_hwc = private_hwc; + } else { + LIST_INITHEAD(&private_output->layer_list); + LIST_INITHEAD(&private_output->layer_commit_handler_list); + } + } else { + /* need_new_caps will be true only in case of "disconnected -> connected" and "connected -> disconnected" + * because we have to get new modes. + */ + if (need_new_caps) { + _tdm_display_destroy_caps_output(&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); + + if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + private_output->current_mode = NULL; + } } - for (i = 0; i < layer_count; i++) { - ret = _tdm_display_update_layer(private_output, layers[i], i); + /* do not use the layer object when the tdm_output has the hwc capability */ + if ((private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) == 0) { + layers = func_output->output_get_layers(output_backend, &layer_count, &ret); if (ret != TDM_ERROR_NONE) { free(layers); return ret; } - } - free(layers); + for (i = 0; i < layer_count; i++) { + ret = _tdm_display_update_layer(private_output, layers[i], i); + if (ret != TDM_ERROR_NONE) { + free(layers); + return ret; + } + } + + free(layers); + } return TDM_ERROR_NONE; } @@ -1005,6 +1083,10 @@ tdm_display_init(tdm_error *error) if (ret != TDM_ERROR_NONE) goto failed_load; + ret = tdm_hwc_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_load; + ret = tdm_pp_init(private_display); if (ret != TDM_ERROR_NONE) goto failed_load; @@ -1054,15 +1136,6 @@ tdm_display_init(tdm_error *error) private_display->init_count = 1; g_private_display = private_display; - tdm_private_module *b = NULL; - tdm_private_output *o = NULL; - 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); - } - } - /* the COMMIT_PER_VBLANK functionality is ability of an output to support * several operational modes (commit_per_vblank modes) related to tdm_commit; * this functionality can be turned off which means a default mode */ diff --git a/src/tdm_backend.c b/src/tdm_backend.c index 8be51f0..13ea24c 100644 --- a/src/tdm_backend.c +++ b/src/tdm_backend.c @@ -133,6 +133,31 @@ tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer) /* LCOV_EXCL_START */ EXTERN tdm_error +tdm_backend_register_func_hwc(tdm_display *dpy, tdm_func_hwc *func_hwc) +{ + tdm_backend_module *module; + + TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); + + BACKEND_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(func_hwc != NULL, TDM_ERROR_INVALID_PARAMETER); + + assert(private_display->current_module); + + 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_module->func_hwc = *func_hwc; + + return TDM_ERROR_NONE; +} + +EXTERN tdm_error tdm_backend_register_func_hwc_window(tdm_display *dpy, tdm_func_hwc_window *func_hwc_window) { tdm_backend_module *module; @@ -205,49 +230,3 @@ tdm_backend_register_func_capture(tdm_display *dpy, return TDM_ERROR_NONE; } - -/* LCOV_EXCL_START */ -/* backend operates itself types */ -static tdm_private_output* -_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_module *private_module = NULL; - - 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; - - if (o->output_backend == backend_output) { - frontend_output = o; - return frontend_output; - } - } - } - - return NULL; -} - -EXTERN tdm_error -tdm_backend_trigger_need_validate_event(tdm_output *output) -{ - tdm_private_output *private_output; - uint64_t value; - int res; - - private_output = _look_for_frontend_hwc_output(output); - TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER); - - value = 1; - - /* do not lock the global display lock here */ - - res = write(private_output->need_validate.event_fd, &value, sizeof(value)); - if (res < 0) - return TDM_ERROR_OPERATION_FAILED; - - return TDM_ERROR_NONE; -} -/* LCOV_EXCL_STOP */ diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c new file mode 100644 index 0000000..115197c --- /dev/null +++ b/src/tdm_hwc.c @@ -0,0 +1,550 @@ +/************************************************************************** + * + * libtdm + * + * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: SooChan Lim , + * Boram Park , + * Changyeon Lee , + * Sangjin Lee + * + * 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. + * +**************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "tdm_private.h" + +#define HWC_FUNC_ENTRY() \ + tdm_private_display *private_display; \ + tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ + tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ + TDM_RETURN_VAL_IF_FAIL(hwc != NULL, TDM_ERROR_INVALID_PARAMETER); \ + private_hwc = (tdm_private_hwc*)hwc; \ + private_output = private_hwc->private_output; \ + TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER); \ + private_display = private_output->private_display + +#define HWC_FUNC_ENTRY_ERROR() \ + tdm_private_display *private_display; \ + tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ + tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(hwc != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ + private_hwc = (tdm_private_hwc*)hwc; \ + private_output = private_hwc->private_output; \ + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ + private_display = private_output->private_display + +#define HWC_FUNC_ENTRY_VOID_RETURN() \ + tdm_private_display *private_display; \ + tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ + tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ + TDM_RETURN_IF_FAIL(hwc != NULL); \ + private_hwc = (tdm_private_hwc*)hwc; \ + private_output = private_hwc->private_output; \ + TDM_RETURN_IF_FAIL(private_output != NULL); \ + private_display = private_output->private_display + + +static tdm_private_hwc_window * +_tdm_hwc_find_private_hwc_window(tdm_private_hwc *private_hwc, tdm_hwc_window *hwc_window_backend) +{ + tdm_private_hwc_window *private_hwc_window = NULL; + + LIST_FOR_EACH_ENTRY(private_hwc_window, &private_hwc->hwc_window_list, link) { + if (private_hwc_window->hwc_window_backend == hwc_window_backend) + return private_hwc_window; + } + + return NULL; +} + +static void +_tdm_hwc_thread_cb_commit(tdm_private_display *private_display, void *object, + tdm_thread_cb_base *cb_base, void *user_data) +{ + tdm_thread_cb_hwc_commit *hwc_commit = (tdm_thread_cb_hwc_commit *)cb_base; + tdm_private_hwc_commit_handler *hwc_commit_handler = hwc_commit->base.data; + tdm_private_hwc *private_hwc = object; + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + if (!hwc_commit_handler) + return; + + assert(hwc_commit_handler->owner_tid == syscall(SYS_gettid)); + + tdm_thread_cb_remove(private_hwc, TDM_THREAD_CB_HWC_COMMIT, hwc_commit_handler, + _tdm_hwc_thread_cb_commit, NULL); + + LIST_DEL(&hwc_commit_handler->link); + + if (tdm_debug_module & TDM_DEBUG_COMMIT) { + TDM_INFO("----------------------------------------- hwc(%d) committed", private_hwc->index); + TDM_INFO("handler(%p)", hwc_commit_handler); + } + + if (hwc_commit_handler->func) { + _pthread_mutex_unlock(&private_display->lock); + hwc_commit_handler->func(private_hwc, + hwc_commit->sequence, + hwc_commit->tv_sec, + hwc_commit->tv_usec, + hwc_commit_handler->user_data); + _pthread_mutex_lock(&private_display->lock); + } + + free(hwc_commit_handler); + + if (tdm_debug_module & TDM_DEBUG_COMMIT) + TDM_INFO("-----------------------------------------..."); +} + +static void +_tdm_hwc_cb_commit(tdm_hwc *hwc_backend, unsigned int sequence, + unsigned int tv_sec, unsigned int tv_usec, void *user_data) +{ + tdm_private_hwc_commit_handler *hwc_commit_handler = user_data; + tdm_private_hwc *private_hwc; + tdm_thread_cb_hwc_commit hwc_commit; + tdm_error ret; + + if (hwc_commit_handler) + private_hwc = hwc_commit_handler->private_hwc; + else + private_hwc = tdm_display_find_private_hwc(tdm_display_get(), hwc_backend); + + memset(&hwc_commit, 0, sizeof hwc_commit); + hwc_commit.base.type = TDM_THREAD_CB_HWC_COMMIT; + hwc_commit.base.length = sizeof hwc_commit; + hwc_commit.base.object_stamp = private_hwc->stamp; + hwc_commit.base.data = hwc_commit_handler; + hwc_commit.base.sync = 0; + hwc_commit.sequence = sequence; + hwc_commit.tv_sec = tv_sec; + hwc_commit.tv_usec = tv_usec; + + ret = tdm_thread_cb_call(private_hwc, &hwc_commit.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); +} + +INTERN tdm_error +tdm_hwc_init(tdm_private_display *private_display) +{ + tdm_thread_cb_set_find_func(TDM_THREAD_CB_HWC_COMMIT, tdm_display_find_hwc_stamp); + + return TDM_ERROR_NONE; +} + +EXTERN tdm_hwc_window * +tdm_hwc_create_window(tdm_hwc *hwc, tdm_error *error) +{ + tdm_hwc_window *hwc_window = NULL; + + HWC_FUNC_ENTRY_ERROR(); + + _pthread_mutex_lock(&private_display->lock); + + hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_hwc, error); + + _pthread_mutex_unlock(&private_display->lock); + + return hwc_window; +} + +EXTERN tdm_error +tdm_hwc_get_supported_formats(tdm_hwc *hwc, const tbm_format **formats, int *count) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc; + + HWC_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_output->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_get_supported_formats) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + ret = func_hwc->hwc_get_supported_formats(private_hwc->hwc_backend, formats, count); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN tdm_error +tdm_hwc_get_available_properties(tdm_hwc *hwc, const tdm_prop **props, int *count) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + + HWC_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER); + TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_output->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_get_available_properties) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + ret = func_hwc->hwc_get_available_properties(private_hwc->hwc_backend, props, count); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN tbm_surface_queue_h +tdm_hwc_get_client_target_buffer_queue(tdm_hwc *hwc, tdm_error *error) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + tbm_surface_queue_h queue = NULL; + + HWC_FUNC_ENTRY_ERROR(); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_get_client_target_buffer_queue) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return NULL; + /* LCOV_EXCL_STOP */ + } + + queue = func_hwc->hwc_get_client_target_buffer_queue(private_hwc->hwc_backend, error); + + _pthread_mutex_unlock(&private_display->lock); + + return queue; +} + +EXTERN tdm_error +tdm_hwc_set_client_target_buffer(tdm_hwc *hwc, tbm_surface_h target_buffer, tdm_region damage) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + + HWC_FUNC_ENTRY(); + + _pthread_mutex_lock(&private_display->lock); + + if (tdm_debug_dump & TDM_DUMP_FLAG_WINDOW) { + /* LCOV_EXCL_START */ + char str[TDM_PATH_LEN]; + static int i; + snprintf(str, TDM_PATH_LEN, "target_window_%03d", i++); + tdm_helper_dump_buffer_str(target_buffer, tdm_debug_dump_dir, str); + /* LCOV_EXCL_STOP */ + } + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_set_client_target_buffer) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + ret = func_hwc->hwc_set_client_target_buffer(private_hwc->hwc_backend, target_buffer, damage); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + + +EXTERN tdm_error +tdm_hwc_validate(tdm_hwc *hwc, tdm_hwc_window **composited_wnds, uint32_t num_wnds, uint32_t *num_types) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + tdm_private_hwc_window **composited_wnds_frontend = NULL; + tdm_hwc_window **composited_wnds_backend = NULL; + int i; + + HWC_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(num_types != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_validate) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + if (num_wnds == 0) { + ret = func_hwc->hwc_validate(private_hwc->hwc_backend, NULL, 0, num_types); + + _pthread_mutex_unlock(&private_display->lock); + return ret; + } + + composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *)); + if (!composited_wnds_backend) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ + } + + composited_wnds_frontend = (tdm_private_hwc_window **)composited_wnds; + + for (i = 0; i < num_wnds; i++) + composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend; + + ret = func_hwc->hwc_validate(private_hwc->hwc_backend, composited_wnds_backend, + num_wnds, num_types); + + free(composited_wnds_backend); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN tdm_error +tdm_hwc_get_changed_composition_types(tdm_hwc *hwc, uint32_t *num_elements, + tdm_hwc_window **hwc_window, + tdm_hwc_window_composition *composition_types) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + tdm_private_hwc_window * private_hwc_window = NULL; + int i = 0; + + HWC_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(num_elements != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_get_changed_composition_types) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + ret = func_hwc->hwc_get_changed_composition_types(private_hwc->hwc_backend, + num_elements, hwc_window, composition_types); + if (ret != TDM_ERROR_NONE) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + return ret; + /* LCOV_EXCL_STOP */ + } + + if (hwc_window == NULL || composition_types == NULL) { + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NONE; + } + + for (i = 0; i < *num_elements; i++) { + private_hwc_window = _tdm_hwc_find_private_hwc_window(private_hwc, hwc_window[i]); + if (private_hwc_window == NULL) { + /* LCOV_EXCL_START */ + TDM_ERR("failed! This should never happen!"); + tdm_hwc_window_destroy_internal(private_hwc_window); + *num_elements = 0; + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OPERATION_FAILED; + /* LCOV_EXCL_STOP */ + } + + hwc_window[i] = (tdm_hwc_window*)private_hwc_window; + } + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN tdm_error +tdm_hwc_accept_changes(tdm_hwc *hwc) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + + HWC_FUNC_ENTRY(); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_validate) { + /* LCOV_EXCL_START */ + _pthread_mutex_unlock(&private_display->lock); + TDM_WRN("not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + + ret = func_hwc->hwc_accept_changes(private_hwc->hwc_backend); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN tdm_error +tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_data) +{ + tdm_private_module *private_module; + tdm_func_hwc *func_hwc = NULL; + tdm_private_hwc_commit_handler *hwc_commit_handler = NULL; + + HWC_FUNC_ENTRY(); + + _pthread_mutex_lock(&private_display->lock); + + private_module = private_hwc->private_module; + func_hwc = &private_module->func_hwc; + + if (!func_hwc->hwc_commit) { + /* LCOV_EXCL_START */ + TDM_WRN("not implemented!!"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_NOT_IMPLEMENTED; + /* LCOV_EXCL_STOP */ + } + +//TODO: I am not sure yet whether we have to check the dpms at hwc_commit. +#if 0 + /* check if the dpms is off */ + if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) { + TDM_ERR("hwc(%d) dpms: %s", private_hwc->index, + tdm_dpms_str(private_output->current_dpms_value)); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_DPMS_OFF; + } +#endif + + if (tdm_debug_module & TDM_DEBUG_COMMIT) + TDM_INFO("hwc(%d) commit", private_hwc->index); + + if (!private_hwc->regist_commit_cb) { + private_hwc->regist_commit_cb = 1; + ret = func_hwc->hwc_set_commit_handler(private_hwc->hwc_backend, _tdm_hwc_cb_commit); + /* LCOV_EXCL_START */ + if (ret != TDM_ERROR_NONE) { + private_hwc->regist_commit_cb = 0; + TDM_ERR("hwc(%d) fail to set hwc_set_commit_handler", private_hwc->index); + _pthread_mutex_unlock(&private_display->lock); + return ret; + /* LCOV_EXCL_STOP */ + } + } + + hwc_commit_handler = calloc(1, sizeof(tdm_private_hwc_commit_handler)); + if (!hwc_commit_handler) { + /* LCOV_EXCL_START */ + TDM_ERR("failed: alloc memory"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OUT_OF_MEMORY; + /* LCOV_EXCL_STOP */ + } + + ret = tdm_thread_cb_add(private_hwc, TDM_THREAD_CB_HWC_COMMIT, hwc_commit_handler, + _tdm_hwc_thread_cb_commit, NULL); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("tdm_thread_cb_add failed"); + free(hwc_commit_handler); + return ret; + } + + LIST_ADDTAIL(&hwc_commit_handler->link, &private_hwc->hwc_commit_handler_list); + hwc_commit_handler->private_hwc = private_hwc; + hwc_commit_handler->func = func; + hwc_commit_handler->user_data = user_data; + hwc_commit_handler->owner_tid = syscall(SYS_gettid); + + ret = func_hwc->hwc_commit(private_hwc->hwc_backend, sync, hwc_commit_handler); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed); + + if (tdm_debug_module & TDM_DEBUG_COMMIT) + TDM_INFO("hwc(%d) backend commit: handle(%p) func(%p) user_data(%p)", + private_hwc->index, hwc_commit_handler, func, user_data); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; + +commit_failed: + /* LCOV_EXCL_START */ + if (hwc_commit_handler) { + tdm_thread_cb_remove(private_hwc, TDM_THREAD_CB_HWC_COMMIT, hwc_commit_handler, + _tdm_hwc_thread_cb_commit, NULL); + LIST_DEL(&hwc_commit_handler->link); + free(hwc_commit_handler); + } + + _pthread_mutex_unlock(&private_display->lock); + + return ret; + /* LCOV_EXCL_STOP */ +} \ No newline at end of file diff --git a/src/tdm_hwc_window.c b/src/tdm_hwc_window.c index 25692b3..78df88d 100644 --- a/src/tdm_hwc_window.c +++ b/src/tdm_hwc_window.c @@ -2,14 +2,12 @@ * * libtdm * - * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. + * Copyright 2018 Samsung Electronics co., Ltd. All Rights Reserved. * - * Contact: Eunchul Kim , - * JinYoung Jeon , - * Taeheon Kim , - * YoungJun Cho , - * SooChan Lim , - * Boram Park + * Contact: SooChan Lim , + * Boram Park , + * Changyeon Lee , + * Sangjin Lee * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the @@ -46,35 +44,148 @@ #define HWC_WINDOW_FUNC_ENTRY() \ tdm_private_display *private_display; \ tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ tdm_private_hwc_window *private_hwc_window; \ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ TDM_RETURN_VAL_IF_FAIL(hwc_window != NULL, TDM_ERROR_INVALID_PARAMETER); \ private_hwc_window = (tdm_private_hwc_window*)hwc_window; \ - private_output = private_hwc_window->private_output; \ + private_hwc = private_hwc_window->private_hwc; \ + TDM_RETURN_VAL_IF_FAIL(private_hwc != NULL, TDM_ERROR_INVALID_PARAMETER); \ + private_output = private_hwc->private_output; \ + TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER); \ private_display = private_output->private_display #define HWC_WINDOW_FUNC_ENTRY_ERROR() \ tdm_private_display *private_display; \ tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ tdm_private_hwc_window *private_hwc_window; \ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(hwc_window != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ private_hwc_window = (tdm_private_hwc_window*)hwc_window; \ - private_output = private_hwc_window->private_output; \ + private_hwc = private_hwc_window->private_hwc; \ + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_hwc != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ + private_output = private_hwc->private_output; \ + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ private_display = private_output->private_display #define HWC_WINDOW_FUNC_ENTRY_VOID_RETURN() \ tdm_private_display *private_display; \ tdm_private_output *private_output; \ + tdm_private_hwc *private_hwc; \ tdm_private_hwc_window *private_hwc_window; \ tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\ TDM_RETURN_IF_FAIL(hwc_window != NULL); \ private_hwc_window = (tdm_private_hwc_window*)hwc_window; \ - private_output = private_hwc_window->private_output; \ + private_hwc = private_hwc_window->private_hwc; \ + TDM_RETURN_IF_FAIL(private_hwc != NULL); \ + private_output = private_hwc->private_output; \ + TDM_RETURN_IF_FAIL(private_output != NULL); \ private_display = private_output->private_display -tbm_surface_queue_h -tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error) + +INTERN tdm_hwc_window * +tdm_hwc_window_create_internal(tdm_private_hwc *private_hwc, tdm_error *error) +{ + tdm_private_output *private_output = private_hwc->private_output; + tdm_private_module *private_module = private_output->private_module; + tdm_func_hwc *func_hwc = &private_module->func_hwc; + tdm_private_hwc_window *private_hwc_window = NULL; + tdm_hwc_window *hwc_window_backend = NULL; + tdm_error ret = TDM_ERROR_NONE; + + TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); + + if (!func_hwc->hwc_create_window) { + /* LCOV_EXCL_START */ + if (error) + *error = TDM_ERROR_BAD_MODULE; + return NULL; + /* LCOV_EXCL_STOP */ + } + + private_hwc_window = calloc(1, sizeof(tdm_private_hwc_window)); + if (!private_hwc_window) { + /* LCOV_EXCL_START */ + TDM_ERR("failed: alloc memory"); + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + return NULL; + /* LCOV_EXCL_STOP */ + } + + hwc_window_backend = func_hwc->hwc_create_window(private_hwc->hwc_backend, &ret); + if (ret != TDM_ERROR_NONE) { + free(private_hwc_window); + if (error) + *error = ret; + return NULL; + } + + LIST_ADD(&private_hwc_window->link, &private_hwc->hwc_window_list); + + private_hwc_window->private_hwc = private_hwc; + private_hwc_window->hwc_window_backend = hwc_window_backend; + + TDM_DBG("hwc_window(%p) create", private_hwc_window); + + if (error) + *error = TDM_ERROR_NONE; + + return private_hwc_window; +} + +INTERN void +tdm_hwc_window_destroy_internal(tdm_private_hwc_window *private_hwc_window) +{ + tdm_private_output *private_output; + tdm_private_module *private_module; + tdm_private_hwc *private_hwc; + tdm_func_hwc_window *func_hwc_window; + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + if (!private_hwc_window) + return; + + private_hwc = private_hwc_window->private_hwc; + private_output = private_hwc->private_output; + private_module = private_output->private_module; + func_hwc_window = &private_module->func_hwc_window; + + LIST_DEL(&private_hwc_window->link); + + func_hwc_window = &private_module->func_hwc_window; + func_hwc_window->hwc_window_destroy(private_hwc_window->hwc_window_backend); + + free(private_hwc_window); +} + +EXTERN void +tdm_hwc_window_destroy(tdm_hwc_window *hwc_window) +{ + tdm_private_display *private_display; + tdm_private_output *private_output; + tdm_private_hwc *private_hwc; + tdm_private_hwc_window *private_hwc_window; + + if (!hwc_window) + return; + + private_hwc_window = (tdm_private_hwc_window *)hwc_window; + private_hwc = private_hwc_window->private_hwc; + private_output = private_hwc->private_output; + private_display = private_output->private_display; + + _pthread_mutex_lock(&private_display->lock); + + tdm_hwc_window_destroy_internal(hwc_window); + + _pthread_mutex_unlock(&private_display->lock); +} + +EXTERN tbm_surface_queue_h +tdm_hwc_window_get_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error) { tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; @@ -87,7 +198,8 @@ tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error private_module = private_output->private_module; func_hwc_window = &private_module->func_hwc_window; - if (!func_hwc_window->hwc_window_get_tbm_buffer_queue) { + if (!func_hwc_window->hwc_window_get_buffer_queue) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_WRN("not implemented!!"); if (error) @@ -95,7 +207,7 @@ tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error return NULL; } - queue = func_hwc_window->hwc_window_get_tbm_buffer_queue(private_hwc_window->hwc_window_backend, error); + queue = func_hwc_window->hwc_window_get_buffer_queue(private_hwc_window->hwc_window_backend, error); _pthread_mutex_unlock(&private_display->lock); @@ -132,7 +244,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_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_region damage) { tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; @@ -237,339 +349,7 @@ 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_module *private_module; - tdm_func_hwc_window *func_hwc_window; - - HWC_WINDOW_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_unset_buffer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_unset_buffer(private_hwc_window->hwc_window_backend); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -INTERN tdm_hwc_window * -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_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; - - TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL); - - if (!is_video) { - if (!func_output->output_hwc_create_window) { - if (error) - *error = TDM_ERROR_BAD_MODULE; - return NULL; - } - - hwc_window_backend = func_output->output_hwc_create_window( - private_output->output_backend, &ret); - if (ret != TDM_ERROR_NONE) { - if (error) - *error = ret; - return NULL; - } - } else { - if (!func_output->output_hwc_create_video_window) { - if (error) - *error = TDM_ERROR_NOT_IMPLEMENTED; - return NULL; - } - - hwc_window_backend = func_output->output_hwc_create_video_window( - private_output->output_backend, &ret); - if (ret != TDM_ERROR_NONE) { - if (error) - *error = ret; - return NULL; - } - } - - private_hwc_window = calloc(1, sizeof(tdm_private_hwc_window)); - if (!private_hwc_window) { - TDM_ERR("failed: alloc memory"); - func_output->output_hwc_destroy_window(private_output->output_backend, hwc_window_backend); - if (error) - *error = TDM_ERROR_OUT_OF_MEMORY; - return NULL; - } - - LIST_ADD(&private_hwc_window->link, &private_output->hwc_window_list); - - private_hwc_window->private_display = private_display; - private_hwc_window->private_output = private_output; - private_hwc_window->hwc_window_backend = hwc_window_backend; - - TDM_DBG("hwc_window(%p) create", private_hwc_window); - - if (error) - *error = TDM_ERROR_NONE; - - return private_hwc_window; -} - -INTERN tdm_error -tdm_hwc_window_destroy_internal(tdm_private_hwc_window * private_hwc_window) -{ - tdm_private_output *private_output; - tdm_private_module *private_module; - tdm_func_output *func_output; - - TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); - - if (!private_hwc_window) - return TDM_ERROR_OPERATION_FAILED; - - private_output = private_hwc_window->private_output; - private_module = private_output->private_module; - - LIST_DEL(&private_hwc_window->link); - - 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); - return TDM_ERROR_NONE; -} - -EXTERN tdm_error -tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags) -{ - tdm_private_module *private_module; - tdm_func_hwc_window *func_hwc_window = NULL; - - HWC_WINDOW_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_set_flags) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_set_flags(private_hwc_window->hwc_window_backend, flags); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_hwc_window_unset_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags) -{ - tdm_private_module *private_module; - tdm_func_hwc_window *func_hwc_window = NULL; - - HWC_WINDOW_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_unset_flags) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_unset_flags(private_hwc_window->hwc_window_backend, flags); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -static void -_tdm_hwc_window_layer_commit_handler(tdm_layer *layer, unsigned int sequence, - unsigned int tv_sec, unsigned int tv_usec, - void *user_data) -{ - tdm_private_hwc_window_commit_handler *hwc_window_commit_handler = (tdm_private_hwc_window_commit_handler *)user_data; - tdm_hwc_window_commit_handler func = hwc_window_commit_handler->func; - tdm_hwc_window *hwc_window = (tdm_hwc_window *)hwc_window_commit_handler->private_hwc_window; - void *data = hwc_window_commit_handler->user_data; - - func(hwc_window, sequence, tv_sec, tv_usec, data); - - free(hwc_window_commit_handler); -} - -tdm_error -tdm_hwc_window_commit(tdm_hwc_window *hwc_window, tdm_hwc_window_commit_handler func, void *user_data) -{ - 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; - tdm_private_layer *private_layer; - tdm_info_layer *info_layer; - tdm_hwc_window_info window_info; - tbm_surface_h buffer; - - HWC_WINDOW_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_get_layer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - layer = func_hwc_window->hwc_window_get_layer(private_hwc_window->hwc_window_backend, - &ret); - if (!layer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("no assigned layer!!"); - return TDM_ERROR_INVALID_PARAMETER; - } - - private_layer = (tdm_private_layer*)layer; - - buffer = func_hwc_window->hwc_window_get_buffer(private_hwc_window->hwc_window_backend, - &ret); - if (buffer) - ret = tdm_layer_set_buffer_internal(private_layer, buffer); - else - ret = tdm_layer_unset_buffer_internal(private_layer); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: layer set buffer(window)"); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - ret = func_hwc_window->hwc_window_get_info(private_hwc_window->hwc_window_backend, - &window_info); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: commit layer(window)"); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - info_layer = (tdm_info_layer *)&window_info; - ret = tdm_layer_set_info_internal(private_layer, info_layer); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: layer set info(window)"); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - hwc_window_commit_handler = calloc(1, sizeof(tdm_private_hwc_window_commit_handler)); - if (!hwc_window_commit_handler) { - TDM_ERR("failed: alloc memory"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OUT_OF_MEMORY; - } - - hwc_window_commit_handler->private_hwc_window = private_hwc_window; - hwc_window_commit_handler->func = func; - hwc_window_commit_handler->user_data = user_data; - - ret = tdm_layer_commit_internal(private_layer, _tdm_hwc_window_layer_commit_handler, hwc_window_commit_handler); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: commit layer(window)"); - free(hwc_window_commit_handler); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_hwc_window_video_get_capability(tdm_hwc_window *hwc_window, - tdm_hwc_window_video_capability *video_capability) -{ - tdm_private_module *private_module; - tdm_func_hwc_window *func_hwc_window = NULL; - - HWC_WINDOW_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(video_capability != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_video_get_capability) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_video_get_capability(private_hwc_window->hwc_window_backend, - video_capability); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_hwc_window_video_get_available_properties(tdm_hwc_window *hwc_window, - const tdm_prop **props, int *count) -{ - tdm_private_module *private_module; - tdm_func_hwc_window *func_hwc_window = NULL; - - HWC_WINDOW_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_hwc_window = &private_module->func_hwc_window; - - if (!func_hwc_window->hwc_window_video_get_available_properties) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_hwc_window->hwc_window_video_get_available_properties(private_hwc_window->hwc_window_backend, - props, count); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_hwc_window_video_get_property(tdm_hwc_window *hwc_window, - unsigned int id, tdm_value *value) +tdm_hwc_window_get_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_value *value) { tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; @@ -583,14 +363,14 @@ tdm_hwc_window_video_get_property(tdm_hwc_window *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) { + if (!func_hwc_window->hwc_window_get_property) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_WRN("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; } - ret = func_hwc_window->hwc_window_video_get_property(private_hwc_window->hwc_window_backend, - id, value); + ret = func_hwc_window->hwc_window_get_property(private_hwc_window->hwc_window_backend, id, value); _pthread_mutex_unlock(&private_display->lock); @@ -598,8 +378,7 @@ tdm_hwc_window_video_get_property(tdm_hwc_window *hwc_window, } EXTERN tdm_error -tdm_hwc_window_video_set_property(tdm_hwc_window *hwc_window, - unsigned int id, tdm_value value) +tdm_hwc_window_set_property(tdm_hwc_window *hwc_window, unsigned int id, tdm_value value) { tdm_private_module *private_module; tdm_func_hwc_window *func_hwc_window = NULL; @@ -611,14 +390,14 @@ tdm_hwc_window_video_set_property(tdm_hwc_window *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) { + if (!func_hwc_window->hwc_window_set_property) { + /* LCOV_EXCL_START */ _pthread_mutex_unlock(&private_display->lock); TDM_WRN("not implemented!!"); return TDM_ERROR_NOT_IMPLEMENTED; } - ret = func_hwc_window->hwc_window_video_set_property(private_hwc_window->hwc_window_backend, - id, value); + ret = func_hwc_window->hwc_window_set_property(private_hwc_window->hwc_window_backend, id, value); _pthread_mutex_unlock(&private_display->lock); diff --git a/src/tdm_macro.h b/src/tdm_macro.h index a84b82a..5b8f861 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -253,7 +253,7 @@ static struct tdm_type_name tdm_cb_type_names[] = { { TDM_THREAD_CB_CAPTURE_DONE, "capture-done" }, { TDM_THREAD_CB_VBLANK_SW, "vblank-sw" }, { TDM_THREAD_CB_VBLANK_CREATE, "vblank-create" }, - { TDM_THREAD_CB_NEED_VALIDATE, "need-validate" }, + { TDM_THREAD_CB_HWC_COMMIT, "hwc-commit" }, }; TDM_TYPE_NAME_FN(cb_type) diff --git a/src/tdm_output.c b/src/tdm_output.c index 9b9d200..ee760c1 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -127,20 +127,6 @@ _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_del } } -static tdm_private_hwc_window * -_tdm_output_find_private_hwc_window(tdm_private_output *private_output, - tdm_hwc_window *hwc_window_backend) -{ - tdm_private_hwc_window *private_hwc_window = NULL; - - LIST_FOR_EACH_ENTRY(private_hwc_window, &private_output->hwc_window_list, link) { - if (private_hwc_window->hwc_window_backend == hwc_window_backend) - return private_hwc_window; - } - - return NULL; -} - INTERN tdm_error tdm_output_init(tdm_private_display *private_display) { @@ -1563,614 +1549,29 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error) return capture; } -/* LCOV_EXCL_START */ -EXTERN tdm_hwc_window * -tdm_output_hwc_create_window(tdm_output *output, tdm_error *error) +EXTERN tdm_hwc * +tdm_output_get_hwc(tdm_output *output, tdm_error *error) { - tdm_hwc_window *hwc_window = NULL; + tdm_private_hwc *private_hwc = NULL; OUTPUT_FUNC_ENTRY_ERROR(); _pthread_mutex_lock(&private_display->lock); - if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) - hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_output, 0, error); - else { - TDM_ERR("output(%p) not support HWC", private_output); + private_hwc = private_output->private_hwc; + if (!private_hwc) { if (error) *error = TDM_ERROR_BAD_REQUEST; - } - - _pthread_mutex_unlock(&private_display->lock); - - return hwc_window; -} - -EXTERN tdm_hwc_window * -tdm_output_hwc_create_video_window(tdm_output *output, tdm_error *error) -{ - tdm_hwc_window *hwc_window = NULL; - - OUTPUT_FUNC_ENTRY_ERROR(); - - _pthread_mutex_lock(&private_display->lock); - - if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) - hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_output, 1, error); - else { - TDM_ERR("output(%p) not support HWC", private_output); - if (error) - *error = TDM_ERROR_BAD_REQUEST; - } - - _pthread_mutex_unlock(&private_display->lock); - - return hwc_window; -} - -EXTERN tdm_error -tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window) -{ - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(hwc_window != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - ret = tdm_hwc_window_destroy_internal(hwc_window); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -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_module *private_module; - tdm_func_output *func_output = NULL; - tdm_private_hwc_window **composited_wnds_frontend = NULL; - tdm_hwc_window **composited_wnds_backend = NULL; - int i; - - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(num_types != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_validate) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - if (num_wnds == 0) { - ret = func_output->output_hwc_validate(private_output->output_backend, NULL, 0, num_types); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; - } - - composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *)); - if (!composited_wnds_backend) { - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OUT_OF_MEMORY; - } - - composited_wnds_frontend = (tdm_private_hwc_window **)composited_wnds; - - for (i = 0; i < num_wnds; i++) - composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend; - - ret = func_output->output_hwc_validate(private_output->output_backend, composited_wnds_backend, num_wnds, num_types); - - free(composited_wnds_backend); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_output_hwc_set_need_validate_handler(tdm_output *output, - tdm_output_need_validate_handler hndl) -{ - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(hndl != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - /* there's no reason to allow this */ - if (private_output->need_validate.hndl) { - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OPERATION_FAILED; - } - - private_output->need_validate.hndl = hndl; - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN 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) -{ - tdm_private_module *private_module; - tdm_func_output *func_output = NULL; - tdm_private_hwc_window * private_hwc_window = NULL; - int i = 0; - - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(num_elements != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_get_changed_composition_types) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_output->output_hwc_get_changed_composition_types(private_output->output_backend, - num_elements, hwc_window, composition_types); - if (ret != TDM_ERROR_NONE) { - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - if (hwc_window == NULL || composition_types == NULL) { - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; - } - - for (i = 0; i < *num_elements; i++) { - - private_hwc_window = _tdm_output_find_private_hwc_window(private_output, hwc_window[i]); - - if (private_hwc_window == NULL) { - TDM_ERR("failed! This should never happen!"); - func_output->output_hwc_destroy_window(private_output->output_backend, hwc_window[i]); - *num_elements = 0; - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OPERATION_FAILED; - } - - hwc_window[i] = (tdm_hwc_window*)private_hwc_window; - } - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -tdm_error -tdm_output_hwc_accept_changes(tdm_output *output) -{ - tdm_private_module *private_module; - tdm_func_output *func_output = NULL; - - OUTPUT_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_validate) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_output->output_hwc_accept_changes(private_output->output_backend); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -tbm_surface_queue_h -tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error) -{ - tdm_private_module *private_module; - tdm_func_output *func_output = NULL; - tbm_surface_queue_h queue = NULL; - - OUTPUT_FUNC_ENTRY_ERROR(); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - if (error) - *error = TDM_ERROR_BAD_REQUEST; - _pthread_mutex_unlock(&private_display->lock); - return NULL; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_get_target_buffer_queue) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); return NULL; } - queue = func_output->output_hwc_get_target_buffer_queue(private_output->output_backend, error); - - _pthread_mutex_unlock(&private_display->lock); - - return queue; -} - -EXTERN tdm_error -tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage) -{ - tdm_private_module *private_module; - tdm_func_output *func_output = NULL; - - OUTPUT_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - if (tdm_debug_dump & TDM_DUMP_FLAG_WINDOW) { - char str[TDM_PATH_LEN]; - static int i; - snprintf(str, TDM_PATH_LEN, "target_window_%d_%03d", - private_output->index, i++); - tdm_helper_dump_buffer_str(target_buffer, tdm_debug_dump_dir, str); - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_set_client_target_buffer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_output->output_hwc_set_client_target_buffer(private_output->output_backend, target_buffer, damage); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -EXTERN tdm_error -tdm_output_hwc_unset_client_target_buffer(tdm_output *output) -{ - tdm_private_module *private_module; - tdm_func_output *func_output = NULL; - - OUTPUT_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_unset_client_target_buffer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_output->output_hwc_unset_client_target_buffer(private_output->output_backend); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -static void -_tdm_output_hwc_layer_commit_handler(tdm_layer *layer, unsigned int sequence, - unsigned int tv_sec, unsigned int tv_usec, - void *user_data) -{ - tdm_private_output_hwc_target_buffer_commit_handler *output_hwc_target_buffer_commit_handler = (tdm_private_output_hwc_target_buffer_commit_handler *)user_data; - tdm_output_hwc_target_buffer_commit_handler func = output_hwc_target_buffer_commit_handler->func; - tdm_output *output = (tdm_output *)output_hwc_target_buffer_commit_handler->private_output; - void *data = output_hwc_target_buffer_commit_handler->user_data; - - func(output, sequence, tv_sec, tv_usec, data); - - free(output_hwc_target_buffer_commit_handler); -} - -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_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; - tdm_private_layer *private_layer; - const tdm_output_mode *mode; - tbm_surface_h buffer; - - OUTPUT_FUNC_ENTRY(); - - _pthread_mutex_lock(&private_display->lock); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_BAD_REQUEST; - } - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_get_client_target_buffer_layer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - layer = func_output->output_hwc_get_client_target_buffer_layer(private_output->output_backend, - &ret); - if (!layer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("no assigned layer!!"); - return TDM_ERROR_INVALID_PARAMETER; - } - - private_layer = (tdm_private_layer*)layer; - - if (!func_output->output_hwc_get_client_target_buffer) { - _pthread_mutex_unlock(&private_display->lock); - TDM_ERR("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - buffer = func_output->output_hwc_get_client_target_buffer(private_output->output_backend, - &ret); - if (buffer) - ret = tdm_layer_set_buffer_internal(private_layer, buffer); - else - ret = tdm_layer_unset_buffer_internal(private_layer); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: layer set info(window)"); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - if (private_output->need_set_target_info) { - mode = private_output->current_mode; - private_output->target_buffer_info.src_config.size.h = mode->hdisplay; - private_output->target_buffer_info.src_config.size.v = mode->vdisplay; - private_output->target_buffer_info.src_config.pos.x = 0; - private_output->target_buffer_info.src_config.pos.y = 0; - private_output->target_buffer_info.src_config.pos.w = mode->hdisplay; - private_output->target_buffer_info.src_config.pos.h = mode->vdisplay; - private_output->target_buffer_info.dst_pos.x = 0; - private_output->target_buffer_info.dst_pos.y = 0; - private_output->target_buffer_info.dst_pos.w = mode->hdisplay; - private_output->target_buffer_info.dst_pos.h = mode->vdisplay; - private_output->target_buffer_info.transform = TDM_TRANSFORM_NORMAL; - - ret = tdm_layer_set_info_internal(private_layer, &private_output->target_buffer_info); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: layer set info(window)"); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - private_output->need_set_target_info = 0; - } - - output_hwc_target_buffer_commit_handler = calloc(1, sizeof(tdm_private_output_hwc_target_buffer_commit_handler)); - if (!output_hwc_target_buffer_commit_handler) { - TDM_ERR("failed: alloc memory"); - _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_OUT_OF_MEMORY; - } - - output_hwc_target_buffer_commit_handler->private_output = private_output; - output_hwc_target_buffer_commit_handler->func = func; - output_hwc_target_buffer_commit_handler->user_data = user_data; - - ret = tdm_layer_commit_internal(private_layer, _tdm_output_hwc_layer_commit_handler, output_hwc_target_buffer_commit_handler); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed: commit layer(target buffer)"); - free(output_hwc_target_buffer_commit_handler); - _pthread_mutex_unlock(&private_display->lock); - return ret; - } - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -tdm_error -tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format **formats, - int *count) -{ - tdm_private_module *private_module; - tdm_func_output *func_output; - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER); - TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); - - _pthread_mutex_lock(&private_display->lock); - - private_module = private_output->private_module; - func_output = &private_module->func_output; - - if (!func_output->output_hwc_get_video_supported_formats) { - _pthread_mutex_unlock(&private_display->lock); - TDM_WRN("not implemented!!"); - return TDM_ERROR_NOT_IMPLEMENTED; - } - - ret = func_output->output_hwc_get_video_supported_formats( - private_output->output_backend, formats, count); - - _pthread_mutex_unlock(&private_display->lock); - - return ret; -} - -static int -_is_hwc_output_still_existed(tdm_private_output *private_output) -{ - tdm_private_module *private_module = private_output->private_module; - tdm_private_output *o = NULL; - - LIST_FOR_EACH_ENTRY(o, &private_module->output_list, link) { - if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) - continue; - - if (o == private_output) - goto exist; - } - - return 0; - -exist: - return 1; -} - -/* gets called on behalf of the ecore-main-loop thread */ -INTERN void -tdm_output_need_validate_handler_thread(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) -{ - tdm_private_output *private_output = object; - - TDM_RETURN_IF_FAIL(private_output != NULL); - - _pthread_mutex_lock(&private_display->lock); - - /* as we get 'private_output' within an event, an output this 'private_output' - * points to can be destroyed already */ - if (!_is_hwc_output_still_existed(private_output)) { - _pthread_mutex_unlock(&private_display->lock); - return; - } + if (error) + *error = TDM_ERROR_NONE; _pthread_mutex_unlock(&private_display->lock); - TDM_INFO("tdm-backend asks for revalidation for the output:%p.", private_output); - - if (private_output->need_validate.hndl) - private_output->need_validate.hndl((tdm_output*)private_output); -} - -/* gets called on behalf of the tdm-thread */ -static tdm_error -_need_validate_handler(int fd, tdm_event_loop_mask mask, void *user_data) -{ - tdm_thread_cb_need_validate ev; - tdm_private_output *private_output; - tdm_error ret; - uint64_t value; - - private_output = (tdm_private_output *)user_data; - - if (read(private_output->need_validate.event_fd, &value, sizeof(value)) < 0) { - TDM_ERR("error while trying to read from a need_validate.event_fd fd."); - return TDM_ERROR_OPERATION_FAILED; - } - - memset(&ev, 0, sizeof ev); - ev.base.type = TDM_THREAD_CB_NEED_VALIDATE; - ev.base.length = sizeof ev; - ev.base.object_stamp = private_output->stamp; - ev.base.data = NULL; - ev.base.sync = 0; - - ret = tdm_thread_cb_call(private_output, &ev.base, 1); - TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - - TDM_INFO("tdm-thread: get a 'need to revalidate' event for the ouptut:%p.", private_output); - - /* who cares about this? */ - return TDM_ERROR_NONE; -} - -INTERN tdm_error -tdm_output_need_validate_event_init(tdm_output *output) -{ - int fd; - - OUTPUT_FUNC_ENTRY(); - - TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); - - if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) { - TDM_ERR("output(%p) not support HWC", private_output); - return TDM_ERROR_BAD_REQUEST; - } - - /* build in eventfd fds into event_loop listened & handled by the tdm-thread */ - fd = eventfd(0, 0); - TDM_WARNING_IF_FAIL(fd >= 0); - - private_output->need_validate.event_source = tdm_event_loop_add_fd_handler(private_display, - fd, TDM_EVENT_LOOP_READABLE, _need_validate_handler, private_output, &ret); - TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - - private_output->need_validate.event_fd = fd; - - TDM_INFO("register an output:%p for the revalidation, event_fd:%d.", private_output, fd); - - return ret; + return private_hwc; } INTERN tdm_error diff --git a/src/tdm_private.h b/src/tdm_private.h index 22c984c..5e1ed84 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -93,6 +93,11 @@ tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp tdm_private_output * tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend); +void * +tdm_display_find_hwc_stamp(tdm_private_display *private_display, double stamp); +tdm_private_hwc * +tdm_display_find_private_hwc(tdm_private_display *private_display, tdm_hwc *hwc_backend); + tdm_error tdm_output_init(tdm_private_display *private_display); @@ -104,8 +109,6 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data); -tdm_error -tdm_output_cb_need_validate(tdm_private_output *private_output); void tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data); @@ -118,10 +121,6 @@ tdm_error tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value); tdm_error -tdm_output_need_validate_event_init(tdm_output *output); -void -tdm_output_need_validate_handler_thread(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data); -tdm_error tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int mode); void @@ -168,9 +167,11 @@ tdm_pp_create_internal(tdm_private_module *private_module, tdm_error *error); void tdm_pp_destroy_internal(tdm_private_pp *private_pp); -tdm_hwc_window * -tdm_hwc_window_create_internal(tdm_private_output *private_output, int is_video, tdm_error *error); tdm_error +tdm_hwc_init(tdm_private_display *private_display); +tdm_hwc_window * +tdm_hwc_window_create_internal(tdm_private_hwc *private_hwc, tdm_error *error); +void tdm_hwc_window_destroy_internal(tdm_private_hwc_window * private_hwc_window); tdm_error diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index 980ebfe..37adf72 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -100,6 +100,7 @@ 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; +typedef struct _tdm_private_hwc tdm_private_hwc; typedef struct _tdm_private_hwc_window tdm_private_hwc_window; typedef struct _tdm_private_pp tdm_private_pp; typedef struct _tdm_private_capture tdm_private_capture; @@ -110,8 +111,7 @@ typedef struct _tdm_private_output_change_handler tdm_private_output_change_hand typedef struct _tdm_private_output_commit_handler tdm_private_output_commit_handler; typedef struct _tdm_private_output_vblank_handler tdm_private_output_vblank_handler; typedef struct _tdm_private_layer_commit_handler tdm_private_layer_commit_handler; -typedef struct _tdm_private_hwc_window_commit_handler tdm_private_hwc_window_commit_handler; -typedef struct _tdm_private_output_hwc_target_buffer_window_commit_handler tdm_private_output_hwc_target_buffer_commit_handler; +typedef struct _tdm_private_hwc_commit_handler tdm_private_hwc_commit_handler; typedef struct _tdm_private_layer_buffer tdm_private_layer_buffer; @@ -130,6 +130,7 @@ struct _tdm_private_module { tdm_func_display func_display; tdm_func_output func_output; tdm_func_layer func_layer; + tdm_func_hwc func_hwc; tdm_func_hwc_window func_hwc_window; tdm_func_pp func_pp; tdm_func_capture func_capture; @@ -196,7 +197,6 @@ struct _tdm_private_output { int regist_dpms_cb; struct list_head layer_list; - struct list_head hwc_window_list; struct list_head capture_list; struct list_head vblank_handler_list; struct list_head output_commit_handler_list; @@ -214,13 +214,6 @@ struct _tdm_private_output { void **layers_ptr; - struct { - /* look at the tdm_output_set_need_revalidate_handler() declaration for the details */ - tdm_output_need_validate_handler hndl; - int event_fd; - tdm_event_loop_source *event_source; - } need_validate; - tdm_info_layer target_buffer_info; /* layer_info for the target_buffer */ /* calling a output commit per a vblank */ @@ -232,6 +225,7 @@ struct _tdm_private_output { /* hwc */ int need_set_target_info; + tdm_private_hwc *private_hwc; }; struct _tdm_private_layer { @@ -271,14 +265,30 @@ struct _tdm_private_layer { unsigned int fps_count; }; -struct _tdm_private_hwc_window { +struct _tdm_private_hwc { struct list_head link; + tdm_private_module *private_module; + int index; + double stamp; - tdm_private_display *private_display; tdm_private_output *private_output; + struct list_head hwc_window_list; + struct list_head hwc_commit_handler_list; + + int regist_commit_cb; + + tdm_hwc *hwc_backend; +}; + +struct _tdm_private_hwc_window { + struct list_head link; + + tdm_private_module *private_module; + + tdm_private_hwc *private_hwc; tdm_hwc_window *hwc_window_backend; }; @@ -394,16 +404,14 @@ struct _tdm_private_output_commit_handler { pid_t owner_tid; }; -struct _tdm_private_hwc_window_commit_handler { - tdm_private_hwc_window *private_hwc_window; - tdm_hwc_window_commit_handler func; - void *user_data; -}; +struct _tdm_private_hwc_commit_handler { + struct list_head link; -struct _tdm_private_output_hwc_target_buffer_window_commit_handler { - tdm_private_output *private_output; - tdm_output_hwc_target_buffer_commit_handler func; + tdm_private_hwc *private_hwc; + tdm_hwc_commit_handler func; void *user_data; + + pid_t owner_tid; }; struct _tdm_private_layer_commit_handler { @@ -458,7 +466,7 @@ typedef enum { TDM_THREAD_CB_CAPTURE_DONE, TDM_THREAD_CB_VBLANK_SW, TDM_THREAD_CB_VBLANK_CREATE, - TDM_THREAD_CB_NEED_VALIDATE, + TDM_THREAD_CB_HWC_COMMIT, TDM_THREAD_CB_MAX, } tdm_thread_cb_type; @@ -471,7 +479,7 @@ typedef struct _tdm_thread_cb_pp_done tdm_thread_cb_pp_done; typedef struct _tdm_thread_cb_capture_done tdm_thread_cb_capture_done; typedef struct _tdm_thread_cb_vblank_sw tdm_thread_cb_vblank_sw; typedef struct _tdm_thread_cb_vblank_create tdm_thread_cb_vblank_create; -typedef struct _tdm_thread_cb_need_validate tdm_thread_cb_need_validate; +typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_hwc_commit; struct _tdm_thread_cb_base { tdm_thread_cb_type type; @@ -518,10 +526,6 @@ struct _tdm_thread_cb_vblank_create { double vblank_stamp; }; -struct _tdm_thread_cb_need_validate { - tdm_thread_cb_base base; -}; - struct argument_details { char type; int nullable; diff --git a/src/tdm_thread.c b/src/tdm_thread.c index ea891a2..997d772 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -459,7 +459,7 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) case TDM_THREAD_CB_CAPTURE_DONE: case TDM_THREAD_CB_VBLANK_SW: case TDM_THREAD_CB_VBLANK_CREATE: - case TDM_THREAD_CB_NEED_VALIDATE: + case TDM_THREAD_CB_HWC_COMMIT: /* this event comes from other thread. so we don't need to propagate this to other thread */ ret = tdm_thread_cb_call(NULL, base, 0); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); diff --git a/utests/Makefile.am b/utests/Makefile.am index 7c22473..7aed5c8 100644 --- a/utests/Makefile.am +++ b/utests/Makefile.am @@ -11,8 +11,6 @@ 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_client.cpp \ src/ut_tdm_backend_env.cpp \ src/ut_tdm_backend_display.cpp \ diff --git a/utests/src/ut_tdm_hwc_window.cpp b/utests/src/ut_tdm_hwc_window.cpp index 12be19c..fb1b190 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/utests/src/ut_tdm_hwc_window.cpp @@ -43,7 +43,6 @@ public: tdm_error error; tdm_hwc_window **hwc_wins; - tdm_hwc_window *video_hwc_win; int hwc_count; }; @@ -67,13 +66,10 @@ void TDMHwcWindow::SetUp(void) 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); + hw = tdm_hwc_create_window(outputs[w], &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[o], &error); } } } @@ -81,26 +77,16 @@ void TDMHwcWindow::SetUp(void) 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); + tdm_hwc_window_destroy(hwc_wins[w]); TDMOutput::TearDown(); } -/* tdm_error tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window); */ +/* void tdm_hwc_window_destroy(tdm_hwc_window *hwc_window); */ +/* TEST_P(TDMHwcWindow, DestroyWindowFailNull) { - 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[o], NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } - } + tdm_hwc_window_destroy(NULL); } TEST_P(TDMHwcWindow, DestroyWindowSuccessful) @@ -111,27 +97,27 @@ TEST_P(TDMHwcWindow, DestroyWindowSuccessful) 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); + hw = tdm_hwc_create_window(outputs[o], &error); ASSERT_EQ(TDM_ERROR_NONE, error); - error = tdm_output_hwc_destroy_window(outputs[o], hw); + error = tdm_hwc_window_destroy(outputs[o], hw); ASSERT_EQ(TDM_ERROR_NONE, error); } } } +*/ - -/* tbm_surface_queue_h tdm_hwc_window_get_tbm_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); */ +/* tbm_surface_queue_h tdm_hwc_window_get_buffer_queue(tdm_hwc_window *hwc_window, tdm_error *error); */ 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); + queue = tdm_hwc_window_get_buffer_queue(NULL, &error); ASSERT_NE(TDM_ERROR_NONE, error); ASSERT_EQ(NULL, queue); - queue = tdm_hwc_window_get_tbm_buffer_queue(NULL, NULL); + queue = tdm_hwc_window_get_buffer_queue(NULL, NULL); ASSERT_EQ(NULL, queue); } @@ -152,12 +138,12 @@ TEST_P(TDMHwcWindow, GetBufferQueueSuccessful) 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[w], &error); + queue = tdm_hwc_window_get_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[w], NULL); + queue = tdm_hwc_window_get_buffer_queue(hwc_wins[w], NULL); tbm_surface_queue_destroy(queue); ASSERT_NE(NULL, queue); } @@ -197,12 +183,12 @@ TEST_P(TDMHwcWindow, SetCompositionTypeFailInvalieCompositionType) } } -/* tdm_error tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_hwc_region damage); */ +/* tdm_error tdm_hwc_window_set_buffer_damage(tdm_hwc_window *hwc_window, tdm_region damage); */ TEST_P(TDMHwcWindow, SetBufferDamageFailNullHwcWindow) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + tdm_region damage = {.num_rects = 0, .rects = NULL}; error = tdm_hwc_window_set_buffer_damage(NULL, damage); ASSERT_NE(TDM_ERROR_NONE, error); @@ -212,7 +198,7 @@ TEST_P(TDMHwcWindow, SetBufferDamageFailNullDamageRects) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_hwc_region damage = {.num_rects = 1, .rects = NULL}; + tdm_region damage = {.num_rects = 1, .rects = NULL}; for (int w = 0; w < hwc_count; w++) { error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage); @@ -226,7 +212,7 @@ 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}; + tdm_region damage = {.num_rects = 1, .rects = rects}; for (int w = 0; w < hwc_count; w++) { error = tdm_hwc_window_set_buffer_damage(hwc_wins[w], damage); @@ -292,92 +278,8 @@ TEST_P(TDMHwcWindow, SetBufferSuccessful) } } -/* tdm_error tdm_hwc_window_set_flags(tdm_hwc_window *hwc_window, tdm_hwc_window_flag flags); */ -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_P(TDMHwcWindow, SetFlagsSuccessful) -{ - TDM_UT_SKIP_FLAG(has_outputs); - - tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; - - for (int w = 0; w < hwc_count; w++) { - - 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_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_P(TDMHwcWindow, UnsetFlagsSuccessful) -{ - TDM_UT_SKIP_FLAG(has_outputs); - - tdm_hwc_window_flag flag = (tdm_hwc_window_flag)0; - - for (int w = 0; w < hwc_count; w++) { - - 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_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); - ASSERT_NE(TDM_ERROR_NONE, error); - - if (hwc_count > 0) { - error = tdm_hwc_window_video_get_capability(hwc_wins[0], NULL); - ASSERT_NE(TDM_ERROR_NONE, error); - } - -} - -TEST_P(TDMHwcWindow, VideoGetCapabilitySuccessful) -{ - TDM_UT_SKIP_FLAG(has_outputs); - - tdm_hwc_window_video_capability video_capability; - - 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[w], &video_capability); - ASSERT_NE(TDM_ERROR_NONE, error); - - if (video_hwc_win != NULL) { - error = tdm_hwc_window_video_get_capability(video_hwc_win, &video_capability); - ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); - } - } -} - - -/* tdm_hwc_window_video_get_available_properties() */ +/* tdm_hwc_get_available_properties() */ +/* TEST_P(TDMHwcWindow, GetAvailablePropertiesFailNullWin) { TDM_UT_SKIP_FLAG(has_outputs); @@ -386,13 +288,13 @@ TEST_P(TDMHwcWindow, GetAvailablePropertiesFailNullWin) const tdm_prop *props; int count; - error = tdm_hwc_window_video_get_available_properties(NULL, &props, &count); + error = tdm_hwc_get_available_properties(NULL, &props, &count); ASSERT_NE(TDM_ERROR_NONE, error); - error = tdm_hwc_window_video_get_available_properties(video_hwc_win, NULL, &count); + error = tdm_hwc_get_available_properties(video_hwc_win, NULL, &count); ASSERT_NE(TDM_ERROR_NONE, error); - error = tdm_hwc_window_video_get_available_properties(video_hwc_win, &props, NULL); + error = tdm_hwc_get_available_properties(video_hwc_win, &props, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -405,11 +307,12 @@ TEST_P(TDMHwcWindow, GetAvailablePropertiesSuccess) const tdm_prop *props; int count; - error = tdm_hwc_window_video_get_available_properties(video_hwc_win, &props, &count); + error = tdm_hwc_get_available_properties(video_hwc_win, &props, &count); ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error); } +*/ -/* tdm_hwc_window_video_get_property() */ +/* tdm_hwc_window_get_property() */ TEST_P(TDMHwcWindow, GetPropertyFailNull) { TDM_UT_SKIP_FLAG(has_outputs); @@ -418,10 +321,10 @@ TEST_P(TDMHwcWindow, GetPropertyFailNull) tdm_value value; int id = 1; - error = tdm_hwc_window_video_get_property(NULL, id, &value); + error = tdm_hwc_window_get_property(NULL, id, &value); ASSERT_NE(TDM_ERROR_NONE, error); - error = tdm_hwc_window_video_get_property(video_hwc_win, id, NULL); + error = tdm_hwc_window_get_property(video_hwc_win, id, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -433,11 +336,11 @@ TEST_P(TDMHwcWindow, GetPropertyFailWrongId) tdm_value value; int id = INT_MAX; - error = tdm_hwc_window_video_get_property(video_hwc_win, id, &value); + error = tdm_hwc_window_get_property(video_hwc_win, id, &value); ASSERT_NE(TDM_ERROR_NONE, error); } -/* tdm_hwc_window_video_set_property() */ +/* tdm_hwc_window_set_property() */ TEST_P(TDMHwcWindow, SetPropertyFailNull) { TDM_UT_SKIP_FLAG(has_outputs); @@ -446,7 +349,7 @@ TEST_P(TDMHwcWindow, SetPropertyFailNull) tdm_value value; int id = 1; - error = tdm_hwc_window_video_set_property(NULL, id, value); + error = tdm_hwc_window_set_property(NULL, id, value); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -458,7 +361,7 @@ TEST_P(TDMHwcWindow, SetPropertyFailWrongId) tdm_value value; int id = INT_MAX; - error = tdm_hwc_window_video_set_property(video_hwc_win, id, value); + error = tdm_hwc_window_set_property(video_hwc_win, id, value); ASSERT_NE(TDM_ERROR_NONE, error); } diff --git a/utests/src/ut_tdm_output_hwc.cpp b/utests/src/ut_tdm_output_hwc.cpp index e84860d..29019c5 100644 --- a/utests/src/ut_tdm_output_hwc.cpp +++ b/utests/src/ut_tdm_output_hwc.cpp @@ -57,15 +57,16 @@ void TDMOutputHwc::TearDown(void) TDMOutput::TearDown(); } -/* tdm_hwc_window * tdm_output_hwc_create_window(tdm_output *output, tdm_error *error); */ +/* tdm_hwc_window * tdm_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_EQ(NULL, tdm_hwc_create_window(NULL, &error)); ASSERT_NE(TDM_ERROR_NONE, error); } +/* TEST_P(TDMOutputHwc, CreateWindowSuccessful) { TDM_UT_SKIP_FLAG(has_outputs); @@ -74,40 +75,40 @@ TEST_P(TDMOutputHwc, CreateWindowSuccessful) 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); + hw = tdm_hwc_create_window(hwc[o], &error); ASSERT_EQ(TDM_ERROR_NONE, error); + tdm_hwc_window_destroy(hw); } else { - ASSERT_EQ(NULL, tdm_output_hwc_create_window(outputs[o], &error)); + ASSERT_EQ(NULL, tdm_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_error tdm_hwc_set_client_target_buffer(tdm_output *output, + tbm_surface_h target_buffer, tdm_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; + tdm_region reg; tbm_surface_h target_buff = CreateBufferForOutput(0); - error = tdm_output_hwc_set_client_target_buffer(NULL, target_buff, reg, NULL, 0 ); + error = tdm_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}; + tdm_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); + error = tdm_hwc_set_client_target_buffer(outputs[o], target_buff, damage, NULL, 0); tbm_surface_internal_destroy(target_buff); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -117,18 +118,18 @@ TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulSetBuff) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + tdm_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, + error = tdm_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, + error = tdm_hwc_set_client_target_buffer(outputs[o], target_buff, damage, NULL, 0); tbm_surface_internal_destroy(target_buff); ASSERT_NE(TDM_ERROR_NONE, error); @@ -140,15 +141,15 @@ TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulResetBuff) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_hwc_region damage = {.num_rects = 0, .rects = NULL}; + tdm_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, + error = tdm_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, + error = tdm_hwc_set_client_target_buffer(outputs[o], NULL, damage, NULL, 0); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -156,18 +157,19 @@ TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulResetBuff) } */ -/* tbm_surface_queue_h tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error); */ +/* tbm_surface_queue_h tdm_hwc_get_client_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); + queue = tdm_hwc_get_client_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); + queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL); ASSERT_EQ(NULL, queue); } @@ -178,11 +180,12 @@ TEST_P(TDMOutputHwc, GetTargetBufferQueueFainNoHwc) 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); + queue = tdm_hwc_get_client_target_buffer_queue(outputs[o], &error); ASSERT_NE(TDM_ERROR_NONE, error); ASSERT_EQ(NULL, queue); } } +*/ TEST_P(TDMOutputHwc, GetTargetBufferQueueSuccessful) { @@ -192,28 +195,28 @@ TEST_P(TDMOutputHwc, GetTargetBufferQueueSuccessful) 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); + queue = tdm_hwc_get_client_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); + queue = tdm_hwc_get_client_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); + queue = tdm_hwc_get_client_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); + queue = tdm_hwc_get_client_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, +/* tdm_error tdm_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) @@ -221,11 +224,11 @@ TEST_P(TDMOutputHwc, ValidateFailNull) TDM_UT_SKIP_FLAG(has_outputs); uint32_t num_types; - error = tdm_output_hwc_validate(NULL, NULL, 0, &num_types); + error = tdm_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); + error = tdm_hwc_validate(outputs[0], NULL, 0, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } } @@ -237,7 +240,7 @@ TEST_P(TDMOutputHwc, ValidateFailNoHwc) uint32_t num_types; for (int o = 0; o < output_count; o++) { - error = tdm_output_hwc_validate(outputs[o], &num_types); + error = tdm_hwc_validate(outputs[o], &num_types); ASSERT_NE(TDM_ERROR_NONE, error); } } @@ -249,31 +252,31 @@ TEST_P(TDMOutputHwc, ValidateSuccessful) 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); + error = tdm_hwc_validate(outputs[o], &num_types); ASSERT_EQ(TDM_ERROR_NONE, error); } else { - error = tdm_output_hwc_validate(outputs[o], &num_types); + error = tdm_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, +/* tdm_error tdm_hwc_get_changed_composition_types(tdm_hwc *hwc, 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); + error = tdm_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); + error = tdm_hwc_get_changed_composition_types(outputs[0], NULL, NULL, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } } @@ -285,11 +288,11 @@ TEST_P(TDMOutputHwc, GetChangedCompositionTypesFailNoHwc) 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); + error = tdm_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) { @@ -309,48 +312,48 @@ TEST_P(TDMHwcWindow, GetChangedCompositionTypesSuccessful) 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); + error = tdm_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); + error = tdm_hwc_get_changed_composition_types(outputs[o], &get_num, NULL, NULL); ASSERT_EQ(TDM_ERROR_NONE, error); ASSERT_EQ(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); + error = tdm_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); + error = tdm_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); */ - +/* tdm_error tdm_hwc_accept_changes(tdm_hwc *hwc); */ +/* TEST_P(TDMOutputHwc, AcceptChangesFailNull) { TDM_UT_SKIP_FLAG(has_outputs); - error = tdm_output_hwc_accept_changes(NULL); + error = tdm_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]); + error = tdm_hwc_accept_changes(outputs[o]); ASSERT_NE(TDM_ERROR_NONE, error); } } - +*/ /* TODO: fix the validate test later. TEST_P(TDMHwcWindow, AcceptChangesSuccessful) { @@ -365,11 +368,11 @@ TEST_P(TDMHwcWindow, AcceptChangesSuccessful) 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); + error = tdm_hwc_validate(outputs[o], &validate_num); ASSERT_EQ(TDM_ERROR_NONE, error); if (validate_num > 0) { - error = tdm_output_hwc_accept_changes(outputs[o]); + error = tdm_hwc_accept_changes(outputs[o]); ASSERT_EQ(TDM_ERROR_NONE, error); } } @@ -377,45 +380,15 @@ TEST_P(TDMHwcWindow, AcceptChangesSuccessful) } */ -/* 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() */ +/* tdm_hwc_get_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); + error = tdm_hwc_get_supported_formats(NULL, NULL, NULL); ASSERT_NE(TDM_ERROR_NONE, error); } @@ -429,18 +402,19 @@ TEST_P(TDMOutputHwc, GetVideoSupportedFormatsSuccessful) 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); + error = tdm_hwc_get_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); + error = tdm_hwc_get_supported_formats(outputs[o], &formats, &count); ASSERT_NE(TDM_ERROR_NONE, error); } } } +*/ #ifdef TDM_UT_TEST_WITH_PARAMS INSTANTIATE_TEST_CASE_P(TDMOutputHwcParams, -- 2.7.4 From 21d7d5d114c1e79b2d9ce2c52bb35c7adbc0a4bd Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Fri, 13 Apr 2018 10:51:29 +0900 Subject: [PATCH 09/16] package version up to 1.17.0 Change-Id: I40c285e4e703d8da3dcf997894885443f2001905 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index c7855e4..e7e92b0 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.16.13 +Version: 1.17.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 0f68df32ed413593c01bd4327f6d3c410e95d091 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Thu, 19 Apr 2018 12:49:51 +0900 Subject: [PATCH 10/16] add pthred_unlock Change-Id: I101904deef6c6045e39d58c948a7ead76ecdc5e8 --- src/tdm_hwc.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tdm_hwc.c b/src/tdm_hwc.c index 115197c..f7ed46f 100644 --- a/src/tdm_hwc.c +++ b/src/tdm_hwc.c @@ -514,6 +514,7 @@ tdm_hwc_commit(tdm_hwc *hwc, int sync, tdm_hwc_commit_handler func, void *user_d if (ret != TDM_ERROR_NONE) { TDM_ERR("tdm_thread_cb_add failed"); free(hwc_commit_handler); + _pthread_mutex_unlock(&private_display->lock); return ret; } -- 2.7.4 From 0eafb5d8afb226969a9b4f1d795540836ee63f65 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Thu, 19 Apr 2018 13:21:48 +0900 Subject: [PATCH 11/16] package version up to 1.17.1 Change-Id: I5a8481fa32f2a3c6a5d74becab4134907862d693 --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index e7e92b0..7082681 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.17.0 +Version: 1.17.1 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From 34018f510c74e4ce3fcffd5d5ed7ce2fb5e836e8 Mon Sep 17 00:00:00 2001 From: Changyeon Lee Date: Mon, 23 Apr 2018 18:06:32 +0900 Subject: [PATCH 12/16] hwc: add tdm_backend_register_func_hwc in tdm_backend.h Change-Id: Idd35dc2d2cc92998c746433a9803ae78f7ae285b --- include/tdm_backend.h | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/include/tdm_backend.h b/include/tdm_backend.h index d43d73c..f4de1a6 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -1210,6 +1210,19 @@ tdm_error tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer); /** + * @brief Register the backend hwc functions to a display + * @param[in] dpy A display object + * @param[in] func_hwc hwc functions + * @return #TDM_ERROR_NONE if success. Otherwise, error value. + * @see tdm_backend_register_func_display, tdm_backend_register_func_output + * @remarks + * A backend module @b SHOULD set the backend hwc functions at least. + * @since 2.0.0 + */ +tdm_error +tdm_backend_register_func_hwc(tdm_display *dpy, tdm_func_hwc *func_hwc) + +/** * @brief Register the backend hwc_window functions to a display * @param[in] dpy A display object * @param[in] func_hwc_window hwc_window functions -- 2.7.4 From 25bcdad6a8f0194f10a78af12fd0440f5689f297 Mon Sep 17 00:00:00 2001 From: Changyeon Lee Date: Wed, 25 Apr 2018 11:51:36 +0900 Subject: [PATCH 13/16] fix build break Change-Id: I2f83c749d48a25a9cb9a62443d02777340129826 --- include/tdm_backend.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/tdm_backend.h b/include/tdm_backend.h index f4de1a6..53f979a 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -1220,7 +1220,7 @@ tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer); * @since 2.0.0 */ tdm_error -tdm_backend_register_func_hwc(tdm_display *dpy, tdm_func_hwc *func_hwc) +tdm_backend_register_func_hwc(tdm_display *dpy, tdm_func_hwc *func_hwc); /** * @brief Register the backend hwc_window functions to a display -- 2.7.4 From deb575f8a41c49857c2bf6d4b562dbc70bd614b0 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Mon, 30 Apr 2018 13:05:28 +0900 Subject: [PATCH 14/16] change the package name change the libtbm-utests to the libtbm-haltests Change-Id: If56366b88d0280d33eb609ac66d28e73c85834e8 --- packaging/libtdm.spec | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 7082681..1e422eb 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -47,11 +47,11 @@ Requires: libtdm-devel Tizen Display Manager Client Library headers %if "%{UTEST_PACKAGE}" == "1" -%package utests +%package haltests Summary: Tizen Display Manager unit tests package Group: Development/Libraries -%description utests +%description haltests Test module for testing libtdm APIs %endif @@ -152,7 +152,7 @@ rm -f %{_unitdir_user}/basic.target.wants/tdm-socket-user.path %{_bindir}/tdm-test-client %if "%{UTEST_PACKAGE}" == "1" -%files utests +%files haltests %defattr(-,root,root,-) %{_bindir}/tdm-utests %endif -- 2.7.4 From 5b4a2597ab95a6bdec70b161c95922f7168fa9d3 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Mon, 30 Apr 2018 13:06:19 +0900 Subject: [PATCH 15/16] package version up to 1.18.0 Change-Id: I9edc4541e61d361a235ae5d333a423712afa054b --- packaging/libtdm.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 1e422eb..0e29b11 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -2,7 +2,7 @@ %define UTEST_GCOV 0 Name: libtdm -Version: 1.17.1 +Version: 1.18.0 Release: 0 Summary: User Library of Tizen Display Manager Group: Development/Libraries -- 2.7.4 From a67472c9cc914fda35f7bd3ea00bd6bba6140f96 Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Fri, 4 May 2018 13:02:16 +0900 Subject: [PATCH 16/16] change the utests to haltests change all symbol and file name. Change-Id: Id48ccad285938dfcbb8f136c71592806c120d47e --- Makefile.am | 4 +- configure.ac | 10 +- haltests/Makefile.am | 45 +++ utests/src/ut_tdm.h => haltests/src/tc_tdm.h | 68 ++-- .../src/tc_tdm_backend_capture.cpp | 88 +++--- .../src/tc_tdm_backend_display.cpp | 280 ++++++++-------- .../src/tc_tdm_backend_env.cpp | 2 +- .../src/tc_tdm_backend_pp.cpp | 112 +++---- .../src/tc_tdm_buffer.cpp | 58 ++-- .../src/tc_tdm_client.cpp | 148 ++++----- .../src/tc_tdm_display.cpp | 10 +- .../ut_tdm_env.cpp => haltests/src/tc_tdm_env.cpp | 2 +- .../src/tc_tdm_event_loop.cpp | 24 +- .../src/tc_tdm_helper.cpp | 18 +- .../src/tc_tdm_hwc_window.cpp | 6 +- .../src/tc_tdm_layer.cpp | 352 ++++++++++----------- .../ut_tdm_log.cpp => haltests/src/tc_tdm_log.cpp | 36 +-- .../src/tc_tdm_main.cpp | 2 +- .../src/tc_tdm_output.cpp | 324 +++++++++---------- .../src/tc_tdm_output_hwc.cpp | 18 +- .../src/tc_tdm_vblank.cpp | 176 +++++------ packaging/libtdm.spec | 20 +- utests/Makefile.am | 45 --- 23 files changed, 924 insertions(+), 924 deletions(-) create mode 100644 haltests/Makefile.am rename utests/src/ut_tdm.h => haltests/src/tc_tdm.h (74%) rename utests/src/ut_tdm_backend_capture.cpp => haltests/src/tc_tdm_backend_capture.cpp (91%) rename utests/src/ut_tdm_backend_display.cpp => haltests/src/tc_tdm_backend_display.cpp (83%) rename utests/src/ut_tdm_backend_env.cpp => haltests/src/tc_tdm_backend_env.cpp (98%) rename utests/src/ut_tdm_backend_pp.cpp => haltests/src/tc_tdm_backend_pp.cpp (86%) rename utests/src/ut_tdm_buffer.cpp => haltests/src/tc_tdm_buffer.cpp (79%) rename utests/src/ut_tdm_client.cpp => haltests/src/tc_tdm_client.cpp (88%) rename utests/src/ut_tdm_display.cpp => haltests/src/tc_tdm_display.cpp (98%) rename utests/src/ut_tdm_env.cpp => haltests/src/tc_tdm_env.cpp (99%) rename utests/src/ut_tdm_event_loop.cpp => haltests/src/tc_tdm_event_loop.cpp (88%) rename utests/src/ut_tdm_helper.cpp => haltests/src/tc_tdm_helper.cpp (96%) rename utests/src/ut_tdm_hwc_window.cpp => haltests/src/tc_tdm_hwc_window.cpp (98%) rename utests/src/ut_tdm_layer.cpp => haltests/src/tc_tdm_layer.cpp (77%) rename utests/src/ut_tdm_log.cpp => haltests/src/tc_tdm_log.cpp (72%) rename utests/src/ut_tdm_main.cpp => haltests/src/tc_tdm_main.cpp (98%) rename utests/src/ut_tdm_output.cpp => haltests/src/tc_tdm_output.cpp (81%) rename utests/src/ut_tdm_output_hwc.cpp => haltests/src/tc_tdm_output_hwc.cpp (96%) rename utests/src/ut_tdm_vblank.cpp => haltests/src/tc_tdm_vblank.cpp (86%) delete mode 100644 utests/Makefile.am diff --git a/Makefile.am b/Makefile.am index c6a6d73..840406a 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,6 +1,6 @@ -if HAVE_UTEST -SUBDIRS = . include protocol common src backends client tools utests +if HAVE_HALTESTS +SUBDIRS = . include protocol common src backends client tools haltests else SUBDIRS = . include protocol common src backends client tools endif diff --git a/configure.ac b/configure.ac index 1829d04..dd27580 100644 --- a/configure.ac +++ b/configure.ac @@ -31,11 +31,11 @@ LT_INIT([disable-static]) # Enable quiet compiles on automake 1.11. m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) -AC_ARG_WITH(utests, AS_HELP_STRING([--with-utests=yes/no], [whether build/run unit tests or not]), - [ utests="$withval" ], - [ utests="no" ]) +AC_ARG_WITH(haltests, AS_HELP_STRING([--with-haltests=yes/no], [whether build/run unit tests or not]), + [ haltests="$withval" ], + [ haltests="no" ]) -AM_CONDITIONAL(HAVE_UTEST, test "x$utests" = "xyes") +AM_CONDITIONAL(HAVE_HALTESTS, test "x$haltests" = "xyes") AC_PATH_PROG([wayland_scanner], [wayland-scanner]) if test x$wayland_scanner = x; then @@ -103,7 +103,7 @@ AC_OUTPUT([ client/libtdm-client.pc client/Makefile tools/Makefile - utests/Makefile]) + haltests/Makefile]) echo "" echo "$PACKAGE_STRING will be compiled with:" diff --git a/haltests/Makefile.am b/haltests/Makefile.am new file mode 100644 index 0000000..276b503 --- /dev/null +++ b/haltests/Makefile.am @@ -0,0 +1,45 @@ +bin_PROGRAMS = tdm-haltests + +tdm_haltests_SOURCES = \ + src/tc_tdm_main.cpp \ + src/tc_tdm_log.cpp \ + src/tc_tdm_env.cpp \ + src/tc_tdm_event_loop.cpp \ + src/tc_tdm_buffer.cpp \ + src/tc_tdm_helper.cpp \ + src/tc_tdm_vblank.cpp \ + src/tc_tdm_display.cpp \ + src/tc_tdm_output.cpp \ + src/tc_tdm_layer.cpp \ + src/tc_tdm_client.cpp \ + src/tc_tdm_backend_env.cpp \ + src/tc_tdm_backend_display.cpp \ + src/tc_tdm_backend_pp.cpp \ + src/tc_tdm_backend_capture.cpp + +tdm_haltests_SOURCES += \ + ../tools/buffers.c + +tdm_haltests_CXXFLAGS = \ + $(CXXFLAGS) \ + $(TDM_CFLAGS) \ + -I../src \ + -I../include \ + -I../client \ + -I../tools \ + -I$(includedir)/gtest \ + -fpermissive +# The flag -w is used, because there are many warnings in libtdm's sources. +# Warnings occur because we build project with g++. +# In C++ we need to use explicit types conversion. + +tdm_haltests_LDFLAGS = \ + ${LDFLAGS} \ + $(TDM_LIBS) \ + $(top_builddir)/src/libtdm.la \ + $(top_builddir)/client/libtdm-client.la \ + $(top_builddir)/common/libtdm-common.la \ + -lgtest + +check: + ./tdm-haltests diff --git a/utests/src/ut_tdm.h b/haltests/src/tc_tdm.h similarity index 74% rename from utests/src/ut_tdm.h rename to haltests/src/tc_tdm.h index b7265fa..853f45a 100644 --- a/utests/src/ut_tdm.h +++ b/haltests/src/tc_tdm.h @@ -112,7 +112,7 @@ extern bool enable_porting_debug; #define TDM_UT_DUMP_DIR "/tmp/tdm_dump" #define TDM_UT_INVALID_VALUE -42 #define TDM_UT_BUFFER_SIZE 256 -#define TDM_UT_VBLANK_NAME "ut_tdm_vblank" +#define TDM_UT_VBLANK_NAME "tc_tdm_vblank" using ::testing::TestWithParam; using ::testing::Bool; @@ -167,40 +167,40 @@ public: extern "C" void __gcov_flush(void); #endif -tdm_error ut_tdm_display_handle_events(tdm_display *dpy); -bool ut_tdm_display_has_pp_capability(tdm_display *dpy); -bool ut_tdm_display_has_capture_capability(tdm_display *dpy); +tdm_error tc_tdm_display_handle_events(tdm_display *dpy); +bool tc_tdm_display_has_pp_capability(tdm_display *dpy); +bool tc_tdm_display_has_capture_capability(tdm_display *dpy); -bool ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, +bool tc_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers); -bool ut_tdm_output_is_async_dpms_enable(tdm_output *output); -bool ut_tdm_output_is_hwc_enable(tdm_output *output); -bool ut_tdm_output_is_aod_enable(tdm_output *output); -bool ut_tdm_output_is_connected(tdm_output *output); -bool ut_tdm_output_mode_setting(tdm_output *output); -bool ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill); -bool ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill); -bool ut_tdm_output_unset(tdm_display *dpy, tdm_output *output); -double ut_tdm_output_get_vblank_interval_time(tdm_output *output); -tdm_layer *ut_tdm_output_get_primary_layer(tdm_output *output); - -bool ut_tdm_layer_is_cursor_layer(tdm_layer *layer); -bool ut_tdm_layer_is_primary_layer(tdm_layer *layer); -bool ut_tdm_layer_is_video_layer(tdm_layer *layer); -bool ut_tdm_layer_support_scale(tdm_layer *layer); -bool ut_tdm_layer_support_no_crop(tdm_layer *layer); -bool ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill); -bool ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue); -bool ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info); -bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer); -bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos); -unsigned int ut_tdm_layer_get_output_pipe(tdm_layer *layer); -tbm_format ut_tdm_layer_find_best_format(tdm_layer *layer); -bool ut_tdm_layer_is_avaiable(tdm_layer *layer); - -bool ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info); -bool ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform, +bool tc_tdm_output_is_async_dpms_enable(tdm_output *output); +bool tc_tdm_output_is_hwc_enable(tdm_output *output); +bool tc_tdm_output_is_aod_enable(tdm_output *output); +bool tc_tdm_output_is_connected(tdm_output *output); +bool tc_tdm_output_mode_setting(tdm_output *output); +bool tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill); +bool tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill); +bool tc_tdm_output_unset(tdm_display *dpy, tdm_output *output); +double tc_tdm_output_get_vblank_interval_time(tdm_output *output); +tdm_layer *tc_tdm_output_get_primary_layer(tdm_output *output); + +bool tc_tdm_layer_is_cursor_layer(tdm_layer *layer); +bool tc_tdm_layer_is_primary_layer(tdm_layer *layer); +bool tc_tdm_layer_is_video_layer(tdm_layer *layer); +bool tc_tdm_layer_support_scale(tdm_layer *layer); +bool tc_tdm_layer_support_no_crop(tdm_layer *layer); +bool tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill); +bool tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue); +bool tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info); +bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer); +bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos); +unsigned int tc_tdm_layer_get_output_pipe(tdm_layer *layer); +tbm_format tc_tdm_layer_find_best_format(tdm_layer *layer); +bool tc_tdm_layer_is_avaiable(tdm_layer *layer); + +bool tc_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info); +bool tc_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform, tdm_capture_type type, int frequency, bool stretch, tdm_info_capture *info); /******************************************************************************/ @@ -240,7 +240,7 @@ public: void TearDown(void) { TDMBackendBasic::TearDown(); } }; -char ut_tdm_backend_getchar(void); +char tc_tdm_backend_getchar(void); #define TDM_UT_ASK_YNR(fmt, ...) \ do { \ @@ -248,7 +248,7 @@ char ut_tdm_backend_getchar(void); char ch; \ do { \ printf(fmt" [Y]es, [n]o, [r]etry): ", ##__VA_ARGS__); \ - ch = ut_tdm_backend_getchar(); \ + ch = tc_tdm_backend_getchar(); \ } while(ch != 'y' && ch != 'n' && ch != 'r'); \ if (ch == 'n') \ GTEST_FATAL_FAILURE_("tc failed"); \ diff --git a/utests/src/ut_tdm_backend_capture.cpp b/haltests/src/tc_tdm_backend_capture.cpp similarity index 91% rename from utests/src/ut_tdm_backend_capture.cpp rename to haltests/src/tc_tdm_backend_capture.cpp index 8eca5d6..010153f 100644 --- a/utests/src/ut_tdm_backend_capture.cpp +++ b/haltests/src/tc_tdm_backend_capture.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ class TDMBackendCapture : public TDMBackendDisplay @@ -127,10 +127,10 @@ void TDMBackendCapture::SetUp(void) ASSERT_TRUE(preferred_align == -1 || preferred_align > 0); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); } } @@ -140,10 +140,10 @@ void TDMBackendCapture::TearDown(void) tdm_capture_destroy(capture); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true); + ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); } DestroyBuffers(); @@ -156,7 +156,7 @@ bool TDMBackendCapture::FindLayer(int output_idx, tbm_format fmt, tdm_pos *punch tdm_error ret; int count; int primary_zpos, zpos; - tdm_layer *primary = ut_tdm_output_get_primary_layer(outputs[output_idx]); + tdm_layer *primary = tc_tdm_output_get_primary_layer(outputs[output_idx]); TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(outputs[output_idx], &count) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE); @@ -209,15 +209,15 @@ bool TDMBackendCapture::TestPrepareDefault(void) tdm_error ret; for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; capture = tdm_output_create_capture(outputs[o], &ret); TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(capture != NULL); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[0], 0, false, 3, buffers) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[o], buffers[0], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false, &info) == true); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE); output = outputs[o]; @@ -259,8 +259,8 @@ bool TDMBackendCapture::TestPrepare(int output_idx, int w, int h, tbm_format fmt flags |= TBM_BO_SCANOUT; } - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, fmt, flags, false, 3, buffers) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_capture_fill_info(outputs[output_idx], buffers[0], t, c, frequency, stretch, &info) == true); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_capture_set_info(capture, &info) == TDM_ERROR_NONE); output = outputs[output_idx]; @@ -293,7 +293,7 @@ void TDMBackendCapture::ShowBuffer(int b, tdm_pos *pos) ASSERT_NE(output, NULL); ASSERT_NE(dst_layer, NULL); - ASSERT_EQ(ut_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true); + ASSERT_EQ(tc_tdm_layer_set_buffer_with_pos(dst_layer, buffers[b], pos), true); ASSERT_EQ(tdm_output_commit(output, 0, NULL, NULL), TDM_ERROR_NONE); } @@ -317,7 +317,7 @@ void TDMBackendCapture::DestroyBuffers(void) } static void -_ut_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit) +_tc_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fit) { float rw, rh; @@ -349,7 +349,7 @@ _ut_tdm_capture_fit_rect(int src_w, int src_h, int dst_w, int dst_h, tdm_pos *fi } bool -ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform, +tc_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform transform, tdm_capture_type type, int frequency, bool stretch, tdm_info_capture *info) { int bw, bh; @@ -376,7 +376,7 @@ ut_tdm_capture_fill_info(tdm_output *output, tbm_surface_h buffer, tdm_transform info->dst_config.pos.w = tbm_surface_get_width(buffer); info->dst_config.pos.h = tbm_surface_get_height(buffer); } else { - _ut_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay, + _tc_tdm_capture_fit_rect(mode->hdisplay, mode->vdisplay, tbm_surface_get_width(buffer), tbm_surface_get_height(buffer), &info->dst_config.pos); } @@ -523,7 +523,7 @@ TEST_P(TDMBackendCapture, CaptureSetInfoNullOther) } static void -_ut_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data) +_tc_tdm_capture_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data) { bool *done = (bool*)user_data; if (done) @@ -537,7 +537,7 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandler) ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_NONE); TestDone(); } @@ -547,7 +547,7 @@ TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullObject) TDM_UT_SKIP_FLAG(has_capture_cap); TDM_UT_SKIP_FLAG(capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT); - ASSERT_EQ(tdm_capture_set_done_handler(NULL, _ut_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_capture_set_done_handler(NULL, _tc_tdm_capture_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendCapture, CaptureSetDoneHandlerNullOther) @@ -569,7 +569,7 @@ TEST_P(TDMBackendCapture, CaptureAttach) for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; for (int f = 0; f < format_count; f++) { @@ -635,7 +635,7 @@ TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) ASSERT_EQ(TestPrepareDefault(), true); - ASSERT_EQ(ut_tdm_output_unset(dpy, output), true); + ASSERT_EQ(tc_tdm_output_unset(dpy, output), true); ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); @@ -645,7 +645,7 @@ TEST_P(TDMBackendCapture, CaptureCommitDpmsOff) } static void -_ut_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data) +_tc_tdm_capture_done_cb2(tdm_capture *capture, tbm_surface_h buffer, void *user_data) { int *done = (int*)user_data; if (done) @@ -661,7 +661,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) const tdm_output_mode *mode = NULL; int f = 0; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -671,7 +671,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyWithoutCommit) ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); @@ -692,7 +692,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) const tdm_output_mode *mode = NULL; int f = 0; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -702,7 +702,7 @@ TEST_P(TDMBackendCapture, CaptureDestroyBeforeDone) ASSERT_EQ(TestPrepare(o, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); @@ -727,7 +727,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode = NULL; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -752,7 +752,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotLetterboxSize) ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -761,7 +761,7 @@ retry: ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -793,7 +793,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode = NULL; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -818,7 +818,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotFullSize) ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, true), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -827,7 +827,7 @@ retry: ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -859,7 +859,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode = NULL; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -885,7 +885,7 @@ TEST_P(TDMBackendCapture, CaptureOneshotAttachFewTimesInOneCommit) TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_ONESHOT, -1, false), true); done = 0; - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_done_cb2, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) @@ -894,7 +894,7 @@ retry: ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (done != 3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) { #if 0 @@ -917,18 +917,18 @@ retry: } static void -_ut_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data) +_tc_tdm_backend_capture_buffer_release_cb(tbm_surface_h buffer, void *user_data) { TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data; - tdm_buffer_remove_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, backend_capture); + tdm_buffer_remove_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, backend_capture); ASSERT_EQ(tdm_capture_attach(backend_capture->capture, buffer), TDM_ERROR_NONE); ASSERT_EQ(tdm_capture_commit(backend_capture->capture), TDM_ERROR_NONE); } static void -_ut_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data) +_tc_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void *user_data) { TDMBackendCapture *backend_capture = (TDMBackendCapture*)user_data; @@ -939,7 +939,7 @@ _ut_tdm_capture_stream_done_cb(tdm_capture *capture, tbm_surface_h buffer, void snprintf(temp, sizeof temp, "f%d_b%d", f, b); DumpBuffer(b, temp); #endif - tdm_buffer_add_release_handler(buffer, _ut_tdm_backend_capture_buffer_release_cb, (void*)backend_capture); + tdm_buffer_add_release_handler(buffer, _tc_tdm_backend_capture_buffer_release_cb, (void*)backend_capture); backend_capture->ShowBuffer(b, &backend_capture->dst_pos); break; } @@ -959,7 +959,7 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode = NULL; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -984,7 +984,7 @@ TEST_P(TDMBackendCapture, CaptureStreamLetterboxSize) ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, false), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); @@ -997,7 +997,7 @@ retry: ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!stream_exit) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as letterbox size and show? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, dst_layer_index); @@ -1019,7 +1019,7 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize) for (int o = 0; o < output_count; o++) { const tdm_output_mode *mode = NULL; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); @@ -1044,7 +1044,7 @@ TEST_P(TDMBackendCapture, CaptureStreamFullSize) ASSERT_EQ(TestPrepare(o, half_size, half_size, formats[f], TDM_TRANSFORM_NORMAL, TDM_CAPTURE_TYPE_STREAM, -1, true), true); - ASSERT_EQ(tdm_capture_set_done_handler(capture, _ut_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_capture_set_done_handler(capture, _tc_tdm_capture_stream_done_cb, (void*)this), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_capture_attach(capture, buffers[b]), TDM_ERROR_NONE); @@ -1057,7 +1057,7 @@ retry: ASSERT_EQ(tdm_capture_commit(capture), TDM_ERROR_NONE); while (!stream_exit) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); TDM_UT_ASK_YNR("* Successed to capture a output to a '%c%c%c%c' buffer as full size and show? (output: %d, layer: %d)", FOURCC_STR(formats[f]), pipe, dst_layer_index); diff --git a/utests/src/ut_tdm_backend_display.cpp b/haltests/src/tc_tdm_backend_display.cpp similarity index 83% rename from utests/src/ut_tdm_backend_display.cpp rename to haltests/src/tc_tdm_backend_display.cpp index a5dd08e..7fd8464 100644 --- a/utests/src/ut_tdm_backend_display.cpp +++ b/haltests/src/tc_tdm_backend_display.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -76,7 +76,7 @@ void TDMBackendBasic::SetUp(void) int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE; tdm_error ret; - if (ut_tdm_output_is_hwc_enable(outputs[o])) + if (tc_tdm_output_is_hwc_enable(outputs[o])) continue; ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); @@ -125,7 +125,7 @@ void TDMBackendBasic::DestroyBuffers(void) } char -ut_tdm_backend_getchar(void) +tc_tdm_backend_getchar(void) { int c = getchar(); int ch = c; @@ -255,7 +255,7 @@ TEST_P(TDMBackendBasic, VerifyOutputSetMode) const tdm_output_mode *best = NULL; int count = TDM_UT_INVALID_VALUE; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); @@ -289,7 +289,7 @@ TEST_P(TDMBackendBasic, VerifyOutputSetDpms) tdm_output_dpms got_dpms = TDM_OUTPUT_DPMS_OFF; tdm_output_dpms set_dpms = TDM_OUTPUT_DPMS_ON; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); @@ -321,18 +321,18 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrame) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); retry: - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -351,21 +351,21 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowManyFrames) tdm_layer *layer; int next_buffer = 0; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); retry: - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 3, true), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; @@ -383,7 +383,7 @@ retry: } static void -_ut_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence, +_tc_tdm_backend_output_commit_cb(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { @@ -397,25 +397,25 @@ TEST_P(TDMBackendBasic, VerifyPrimaryLayerShowOneFrameWithCommitHandler) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); retry: - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); bool done = false; - TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE, + TDM_UT_ASSERT_TRUE(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done) == TDM_ERROR_NONE, "Check output_commit(), output_set_commit_handler()"); while (!done) - TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, + TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, "Check display_get_fd(), display_handle_events()"); TDM_UT_ASK_YNR("* Successed to display a frame to a primary layer? (output: %d)", o); @@ -430,17 +430,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowOneFrame) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -453,12 +453,12 @@ retry: if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; ASSERT_EQ(ret, TDM_ERROR_NONE); - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); DestroyBuffers(); } @@ -477,17 +477,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, false), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -500,17 +500,17 @@ TEST_P(TDMBackendBasic, VerifyOverlayLayersShowManyFrames) if (tdm_layer_get_output(layers[l], &ret) != outputs[o]) continue; ASSERT_EQ(ret, TDM_ERROR_NONE); - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; retry: - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); usleep(40000); /* 40 ms */ next_buffer++; @@ -534,7 +534,7 @@ TEST_P(TDMBackendBasic, DISABLED_VerifyCursorLayer) } static void -_ut_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence, +_tc_tdm_backend_output_done_cb(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { @@ -548,17 +548,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -568,14 +568,14 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblank) double start, end, interval; bool done; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done = false; start = tdm_helper_get_time(); - TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE, + TDM_UT_ASSERT_TRUE(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done) == TDM_ERROR_NONE, "Check output_wait_vblank(), output_set_vblank_handler()"); while (!done) - TDM_UT_ASSERT_TRUE(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, + TDM_UT_ASSERT_TRUE(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, "Check display_get_fd(), display_handle_events()"); end = tdm_helper_get_time(); @@ -598,17 +598,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -618,13 +618,13 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankInterval) double start, end, interval; bool done; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -645,17 +645,17 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) for (int o = 0; o < output_count; o++) { tdm_layer *layer; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layer, buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[0]), true); DestroyBuffers(); ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE); @@ -665,15 +665,15 @@ TEST_P(TDMBackendBasic, VerifyOutputWaitVblankFewTimesInOneVblank) double start, end, interval; bool done1, done2, done3; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_backend_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -694,7 +694,7 @@ TEST_P(TDMBackendBasic, VerifyPPObject) tdm_error ret; tdm_pp *pp; - if (!ut_tdm_display_has_pp_capability(dpy)) { + if (!tc_tdm_display_has_pp_capability(dpy)) { TDM_UT_INFO("PP not supported"); return; } @@ -710,7 +710,7 @@ TEST_P(TDMBackendBasic, VerifyPPCapabilities) { tdm_pp_capability capabilities = (tdm_pp_capability)0; - if (!ut_tdm_display_has_pp_capability(dpy)) { + if (!tc_tdm_display_has_pp_capability(dpy)) { TDM_UT_INFO("PP not supported"); return; } @@ -723,7 +723,7 @@ TEST_P(TDMBackendBasic, VerifyPPCapabilities) TEST_P(TDMBackendBasic, VerifyPPAvaiableSize) { - if (!ut_tdm_display_has_pp_capability(dpy)) { + if (!tc_tdm_display_has_pp_capability(dpy)) { TDM_UT_INFO("PP not supported"); return; } @@ -743,7 +743,7 @@ TEST_P(TDMBackendBasic, VerifyPPAvaiableSize) TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats) { - if (!ut_tdm_display_has_pp_capability(dpy)) { + if (!tc_tdm_display_has_pp_capability(dpy)) { TDM_UT_INFO("PP not supported"); return; } @@ -758,7 +758,7 @@ TEST_P(TDMBackendBasic, VerifyPPAvaiableFormats) TEST_P(TDMBackendBasic, VerifyCaptureObject) { - if (!ut_tdm_display_has_capture_capability(dpy)) { + if (!tc_tdm_display_has_capture_capability(dpy)) { TDM_UT_INFO("Capture not supported."); return; } @@ -774,7 +774,7 @@ TEST_P(TDMBackendBasic, VerifyCaptureObject) continue; } - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; capture = tdm_output_create_capture(outputs[o], &ret); @@ -787,7 +787,7 @@ TEST_P(TDMBackendBasic, VerifyCaptureObject) TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize) { - if (!ut_tdm_display_has_capture_capability(dpy)) { + if (!tc_tdm_display_has_capture_capability(dpy)) { TDM_UT_INFO("Capture not supported."); return; } @@ -807,7 +807,7 @@ TEST_P(TDMBackendBasic, VerifyCaptureAvaiableSize) TEST_P(TDMBackendBasic, VerifyCaptureAvaiableFormats) { - if (!ut_tdm_display_has_capture_capability(dpy)) { + if (!tc_tdm_display_has_capture_capability(dpy)) { TDM_UT_INFO("Capture not supported."); return; } @@ -842,33 +842,33 @@ TEST_P(TDMBackendDisplay, VerifyPirmaryLayerFormat) const tdm_output_mode *mode = NULL; unsigned int flags = 0; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - layer = ut_tdm_output_get_primary_layer(outputs[o]); + layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); ASSERT_EQ(tdm_layer_get_buffer_flags(layer, &flags), TDM_ERROR_NONE); ASSERT_EQ(tdm_layer_get_available_formats(layer, &formats, &format_count), TDM_ERROR_NONE); for (int f = 0; f < format_count; f++) { - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for 60 times */ for (int t = 0; t < 60; t++) { tbm_surface_h displaying_buffer; - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -886,7 +886,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -905,11 +905,11 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) output = tdm_layer_get_output(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - if (ut_tdm_layer_is_primary_layer(layer)) + if (tc_tdm_layer_is_primary_layer(layer)) continue; - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); @@ -927,16 +927,16 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerFormat) for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -956,7 +956,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -975,11 +975,11 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) output = tdm_layer_get_output(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - if (ut_tdm_layer_is_primary_layer(layer)) + if (tc_tdm_layer_is_primary_layer(layer)) continue; - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); @@ -1001,16 +1001,16 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerSize) int h = mode->vdisplay - diffh * (f + 1); retry: TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(w, h, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { tbm_surface_h displaying_buffer; - ASSERT_EQ(ut_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layer, buffers[next_buffer]), true); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -1031,7 +1031,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1052,13 +1052,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - if (ut_tdm_layer_is_primary_layer(layer)) + if (tc_tdm_layer_is_primary_layer(layer)) continue; - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; - if (!ut_tdm_layer_support_scale(layer)) { + if (!tc_tdm_layer_support_scale(layer)) { TDM_UT_INFO("no scale capability. (output: %d, layer: %d)", pipe, l); continue; } @@ -1074,7 +1074,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerScale) for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("* testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); tdm_info_layer info; memset(&info, 0, sizeof info); @@ -1097,9 +1097,9 @@ retry: tbm_surface_h displaying_buffer; ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -1120,7 +1120,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1139,11 +1139,11 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) output = tdm_layer_get_output(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - if (ut_tdm_layer_is_primary_layer(layer)) + if (tc_tdm_layer_is_primary_layer(layer)) continue; - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); @@ -1161,7 +1161,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerMovePosition) for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); /* set buffer & commit for TDM_UT_BACKEND_TEST_CNT times */ for (int t = 0; t < TDM_UT_BACKEND_TEST_CNT; t++) { @@ -1185,9 +1185,9 @@ retry: ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -1208,7 +1208,7 @@ retry: TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, false), true); for (int l = 0; l < layer_count; l++) { tdm_error ret; @@ -1229,13 +1229,13 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - if (ut_tdm_layer_is_primary_layer(layer)) + if (tc_tdm_layer_is_primary_layer(layer)) continue; - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; - if (ut_tdm_layer_support_no_crop(layer)) { + if (tc_tdm_layer_support_no_crop(layer)) { TDM_UT_INFO("no crop capability. (output: %d, layer: %d)", pipe, l); continue; } @@ -1253,7 +1253,7 @@ TEST_P(TDMBackendDisplay, VerifyOverlayLayerCrop) for (int f = 0; f < format_count; f++) { retry: TDM_UT_INFO("** testing for %c%c%c%c", FOURCC_STR(formats[f])); - ASSERT_EQ(ut_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); + ASSERT_EQ(tc_tdm_buffer_create(mode->hdisplay, mode->vdisplay, formats[f], flags | TBM_BO_SCANOUT, true, 3, buffers), true); tdm_info_layer info; memset(&info, 0, sizeof info); @@ -1276,9 +1276,9 @@ retry: tbm_surface_h displaying_buffer; ASSERT_EQ(tdm_layer_set_buffer(layer, buffers[next_buffer]), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_EQ(displaying_buffer, buffers[next_buffer]); @@ -1300,10 +1300,10 @@ retry: /* should be debugged int emulator kernel */ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); @@ -1313,10 +1313,10 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOnToOff) /* should be debugged int emulator kernel */ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); @@ -1328,10 +1328,10 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsFromOffToOn) TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); } } @@ -1340,10 +1340,10 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOnBeforeSet) TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_mode_setting(outputs[o]), true); + ASSERT_EQ(tc_tdm_output_mode_setting(outputs[o]), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); } } @@ -1352,12 +1352,12 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffBeforeSet) TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutCommit) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); @@ -1370,12 +1370,12 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithoutComm TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsToOffAfterUnsetWithCommit) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); ASSERT_EQ(tdm_layer_unset_buffer(layer), TDM_ERROR_NONE); @@ -1391,22 +1391,22 @@ TEST_P(TDMBackendDisplay, DISABLED_VerifyOutputSetDpmsAsync) TEST_P(TDMBackendDisplay, VerifyLayerGetInfo) { - ASSERT_EQ(ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); + ASSERT_EQ(tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true), true); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; tbm_surface_h displaying_buffer; tdm_error ret; tdm_info_layer info, temp; - tdm_layer *layer = ut_tdm_output_get_primary_layer(outputs[o]); + tdm_layer *layer = tc_tdm_output_get_primary_layer(outputs[o]); ASSERT_NE(layer, NULL); displaying_buffer = tdm_layer_get_displaying_buffer(layer, &ret); ASSERT_NE(displaying_buffer, NULL); ASSERT_EQ(ret, TDM_ERROR_NONE); - ASSERT_EQ(ut_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true); + ASSERT_EQ(tc_tdm_layer_fill_info(layer, displaying_buffer, NULL, &info), true); ASSERT_EQ(tdm_layer_get_info(layer, &temp), TDM_ERROR_NONE); ASSERT_EQ(memcmp(&info, &temp, sizeof info), 0); } diff --git a/utests/src/ut_tdm_backend_env.cpp b/haltests/src/tc_tdm_backend_env.cpp similarity index 98% rename from utests/src/ut_tdm_backend_env.cpp rename to haltests/src/tc_tdm_backend_env.cpp index 72a7f92..bb4b395 100644 --- a/utests/src/ut_tdm_backend_env.cpp +++ b/haltests/src/tc_tdm_backend_env.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ diff --git a/utests/src/ut_tdm_backend_pp.cpp b/haltests/src/tc_tdm_backend_pp.cpp similarity index 86% rename from utests/src/ut_tdm_backend_pp.cpp rename to haltests/src/tc_tdm_backend_pp.cpp index d7545ac..424b36c 100644 --- a/utests/src/ut_tdm_backend_pp.cpp +++ b/haltests/src/tc_tdm_backend_pp.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -102,7 +102,7 @@ void TDMBackendPP::SetUp(void) { TDMBackendDisplay::SetUp(); - if (!ut_tdm_display_has_pp_capability(dpy)) + if (!tc_tdm_display_has_pp_capability(dpy)) return; ASSERT_EQ(tdm_display_get_pp_capabilities(dpy, &capabilities), TDM_ERROR_NONE); @@ -118,12 +118,12 @@ void TDMBackendPP::SetUp(void) ASSERT_TRUE(preferred_align == -1 || preferred_align > 0); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; output = outputs[o]; ASSERT_EQ(tdm_output_get_pipe(output, &pipe), TDM_ERROR_NONE); - ASSERT_EQ(ut_tdm_output_prepare(dpy, output, false), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, output, false), true); ASSERT_EQ(tdm_output_get_mode(output, &mode), TDM_ERROR_NONE); ASSERT_NE(mode, NULL); break; @@ -174,9 +174,9 @@ bool TDMBackendPP::PrepareBuffers(int sw, int sh, tbm_format sf, int dw, int dh, dst_flags |= TBM_BO_SCANOUT; } - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(sw, sh, sf, src_flags, true, 3, srcbuf) == true); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(dw, dh, df, dst_flags, false, 3, dstbuf) == true); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_pp_fill_info(srcbuf[0], dstbuf[0], t, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(sw, sh, sf, src_flags, true, 3, srcbuf) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(dw, dh, df, dst_flags, false, 3, dstbuf) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_pp_fill_info(srcbuf[0], dstbuf[0], t, &info) == true); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_pp_set_info(pp, &info) == TDM_ERROR_NONE); return true; @@ -187,7 +187,7 @@ bool TDMBackendPP::FindLayerUnderPrimary(void) tdm_error ret; int count; int primary_zpos, zpos; - tdm_layer *primary = ut_tdm_output_get_primary_layer(output); + tdm_layer *primary = tc_tdm_output_get_primary_layer(output); TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE); @@ -217,7 +217,7 @@ bool TDMBackendPP::FindLayerOverPrimary(void) tdm_error ret; int count; int primary_zpos, zpos; - tdm_layer *primary = ut_tdm_output_get_primary_layer(output); + tdm_layer *primary = tc_tdm_output_get_primary_layer(output); TDM_UT_RETURN_FALSE_IF_FAIL(primary != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_zpos(primary, &primary_zpos) == TDM_ERROR_NONE); @@ -242,7 +242,7 @@ bool TDMBackendPP::FindLayerOverPrimary(void) } static void -_ut_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence, +_tc_tdm_backend_pp_output_commit_cb(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { @@ -258,10 +258,10 @@ void TDMBackendPP::ShowBuffer(int b) bool done = false; - ASSERT_EQ(ut_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true); - ASSERT_EQ(tdm_output_commit(output, 0, _ut_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(dst_layer, dstbuf[b]), true); + ASSERT_EQ(tdm_output_commit(output, 0, _tc_tdm_backend_pp_output_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -301,7 +301,7 @@ void TDMBackendPP::DestroyBuffers(void) } bool -ut_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info) +tc_tdm_pp_fill_info(tbm_surface_h srcbuf, tbm_surface_h dstbuf, tdm_transform transform, tdm_info_pp *info) { int bw, bh; @@ -355,7 +355,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; - if (ut_tdm_display_has_pp_capability(dpy)) + if (tc_tdm_display_has_pp_capability(dpy)) ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); else ASSERT_EQ(tdm_display_get_pp_available_formats(NULL, &formats, &count), TDM_ERROR_INVALID_PARAMETER); @@ -365,7 +365,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullObject) TEST_P(TDMBackendPP, PPDispalyGetAvaiableFormatsNullOther) { - if (ut_tdm_display_has_pp_capability(dpy)) { + if (tc_tdm_display_has_pp_capability(dpy)) { ASSERT_EQ(PreparePP(), true); ASSERT_EQ(tdm_display_get_pp_available_formats(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } @@ -378,7 +378,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) int max_w = TDM_UT_INVALID_VALUE; int max_h = TDM_UT_INVALID_VALUE; int preferred_align = TDM_UT_INVALID_VALUE; - if (ut_tdm_display_has_pp_capability(dpy)) + if (tc_tdm_display_has_pp_capability(dpy)) ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); else ASSERT_EQ(tdm_display_get_pp_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER); @@ -391,7 +391,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullObject) TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther) { - if (ut_tdm_display_has_pp_capability(dpy)) { + if (tc_tdm_display_has_pp_capability(dpy)) { ASSERT_EQ(PreparePP(), true); ASSERT_EQ(tdm_display_get_pp_available_size(dpy, NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE); } @@ -399,7 +399,7 @@ TEST_P(TDMBackendPP, PPDispalyGetAvaiableSizeNullOther) TEST_P(TDMBackendPP, PPDestroy) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); tdm_pp_destroy(pp); @@ -408,7 +408,7 @@ TEST_P(TDMBackendPP, PPDestroy) TEST_P(TDMBackendPP, PPDestroyNullObject) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); tdm_pp_destroy(NULL); } @@ -420,7 +420,7 @@ TEST_P(TDMBackendPP, PPSetInfo) TEST_P(TDMBackendPP, PPSetInfoNullObject) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); tdm_info_pp info; memset(&info, 0, sizeof info); @@ -429,14 +429,14 @@ TEST_P(TDMBackendPP, PPSetInfoNullObject) TEST_P(TDMBackendPP, PPSetInfoNullOther) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); ASSERT_EQ(tdm_pp_set_info(pp, NULL), TDM_ERROR_INVALID_PARAMETER); } static void -_ut_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data) +_tc_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data) { bool *done = (bool*)user_data; if (done) @@ -445,22 +445,22 @@ _ut_tdm_pp_done_cb(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_ TEST_P(TDMBackendPP, PPSetDoneHandler) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_NONE); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullObject) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); - ASSERT_EQ(tdm_pp_set_done_handler(NULL, _ut_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_pp_set_done_handler(NULL, _tc_tdm_pp_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); ASSERT_EQ(tdm_pp_set_done_handler(pp, NULL, NULL), TDM_ERROR_INVALID_PARAMETER); @@ -468,7 +468,7 @@ TEST_P(TDMBackendPP, PPSetDoneHandlerNullOther) TEST_P(TDMBackendPP, PPAttach) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -486,7 +486,7 @@ TEST_P(TDMBackendPP, PPAttach) TEST_P(TDMBackendPP, PPAttachNullObject) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); tbm_surface_h srcbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; tbm_surface_h dstbuf = (tbm_surface_h)TDM_UT_BUFFER_SIZE; @@ -496,7 +496,7 @@ TEST_P(TDMBackendPP, PPAttachNullObject) TEST_P(TDMBackendPP, PPAttachNullOther) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -505,7 +505,7 @@ TEST_P(TDMBackendPP, PPAttachNullOther) TEST_P(TDMBackendPP, PPCommit) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -514,14 +514,14 @@ TEST_P(TDMBackendPP, PPCommit) TEST_P(TDMBackendPP, PPCommitNullOBject) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(tdm_pp_commit(NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBackendPP, PPConvertUnderlay) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); FindLayerUnderPrimary(); @@ -538,7 +538,7 @@ TEST_P(TDMBackendPP, PPConvertUnderlay) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -548,7 +548,7 @@ retry: ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -568,7 +568,7 @@ retry: TEST_P(TDMBackendPP, PPConvertOverlay) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); FindLayerOverPrimary(); @@ -585,7 +585,7 @@ TEST_P(TDMBackendPP, PPConvertOverlay) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -595,7 +595,7 @@ retry: ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -615,7 +615,7 @@ retry: TEST_P(TDMBackendPP, PPConvertScale) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); FindLayerUnderPrimary(); @@ -632,7 +632,7 @@ TEST_P(TDMBackendPP, PPConvertScale) mode->hdisplay, mode->vdisplay, dst_formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -642,7 +642,7 @@ retry: ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -662,7 +662,7 @@ retry: TEST_P(TDMBackendPP, PPConvertTransform) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); FindLayerUnderPrimary(); @@ -680,7 +680,7 @@ TEST_P(TDMBackendPP, PPConvertTransform) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[f], (tdm_transform)t), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -690,7 +690,7 @@ retry: ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -711,7 +711,7 @@ retry: TEST_P(TDMBackendPP, PPConvertCSC) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); TDM_UT_SKIP_FLAG(!(capabilities & TDM_PP_CAPABILITY_NO_CSC)); FindLayerUnderPrimary(); @@ -731,7 +731,7 @@ TEST_P(TDMBackendPP, PPConvertCSC) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE / 2, dst_formats[df], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb, &done), TDM_ERROR_NONE); retry: for (int b = 0; b < 3; b++) { @@ -741,7 +741,7 @@ retry: ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); #if 0 char temp[256]; @@ -763,7 +763,7 @@ retry: static void -_ut_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data) +_tc_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user_data) { int *done = (int*)user_data; if (done) @@ -773,7 +773,7 @@ _ut_tdm_pp_done_cb2(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst, void *user /* some backend doens't implement correctly for attaching */ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -786,14 +786,14 @@ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, &done), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); ASSERT_EQ(tdm_pp_commit(pp), TDM_ERROR_NONE); while (done != 3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ShowBuffer(b); @@ -803,7 +803,7 @@ TEST_P(TDMBackendPP, DISABLED_PPAttachFewTimesInOneCommit) TEST_P(TDMBackendPP, PPDestroyWithoutCommit) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -813,7 +813,7 @@ TEST_P(TDMBackendPP, PPDestroyWithoutCommit) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); @@ -825,7 +825,7 @@ TEST_P(TDMBackendPP, PPDestroyWithoutCommit) TEST_P(TDMBackendPP, PPDestroyBeforeDone) { - TDM_UT_SKIP_FLAG(ut_tdm_display_has_pp_capability(dpy)); + TDM_UT_SKIP_FLAG(tc_tdm_display_has_pp_capability(dpy)); ASSERT_EQ(PreparePP(), true); @@ -835,7 +835,7 @@ TEST_P(TDMBackendPP, PPDestroyBeforeDone) TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, formats[f], TDM_TRANSFORM_NORMAL), true); - ASSERT_EQ(tdm_pp_set_done_handler(pp, _ut_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_pp_set_done_handler(pp, _tc_tdm_pp_done_cb2, NULL), TDM_ERROR_NONE); for (int b = 0; b < 3; b++) ASSERT_EQ(tdm_pp_attach(pp, srcbuf[b], dstbuf[b]), TDM_ERROR_NONE); diff --git a/utests/src/ut_tdm_buffer.cpp b/haltests/src/tc_tdm_buffer.cpp similarity index 79% rename from utests/src/ut_tdm_buffer.cpp rename to haltests/src/tc_tdm_buffer.cpp index ec03dba..c2383e4 100644 --- a/utests/src/ut_tdm_buffer.cpp +++ b/haltests/src/tc_tdm_buffer.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -64,7 +64,7 @@ void TDMBuffer::TearDown(void) } bool -ut_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers) +tc_tdm_buffer_create(int width, int height, tbm_format format, int flags, bool fill, int count, tbm_surface_h *buffers) { TDM_UT_GOTO_IF_FAIL(width > 0, failed); TDM_UT_GOTO_IF_FAIL(height > 0, failed); @@ -112,7 +112,7 @@ TEST_P(TDMBuffer, BufferUnrefBackendNullOBject) } static void -_ut_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data) +_tc_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data) { bool *done = (bool*)user_data; if (done) @@ -122,7 +122,7 @@ _ut_tdm_buffer_destroy_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddDestroyHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); tbm_surface_destroy(buffer); buffer = NULL; ASSERT_EQ(done, true); @@ -130,13 +130,13 @@ TEST_P(TDMBuffer, BufferAddDestroyHandler) TEST_P(TDMBuffer, BufferAddDestroyHandlerTwice) { - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullObject) { - ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_buffer_add_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther) @@ -147,8 +147,8 @@ TEST_P(TDMBuffer, BufferAddDestroyHandlerNullOther) TEST_P(TDMBuffer, BufferRemoveDestroyHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); - tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done); tbm_surface_destroy(buffer); buffer = NULL; ASSERT_EQ(done, false); @@ -157,8 +157,8 @@ TEST_P(TDMBuffer, BufferRemoveDestroyHandler) TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData) { bool done = false; - ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); - tdm_buffer_remove_destroy_handler(buffer, _ut_tdm_buffer_destroy_cb, NULL); + ASSERT_EQ(tdm_buffer_add_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, &done), TDM_ERROR_NONE); + tdm_buffer_remove_destroy_handler(buffer, _tc_tdm_buffer_destroy_cb, NULL); tbm_surface_destroy(buffer); buffer = NULL; ASSERT_EQ(done, true); @@ -166,7 +166,7 @@ TEST_P(TDMBuffer, BufferRemoveDestroyHandlerDifferentData) TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullObject) { - tdm_buffer_remove_destroy_handler(NULL, _ut_tdm_buffer_destroy_cb, NULL); + tdm_buffer_remove_destroy_handler(NULL, _tc_tdm_buffer_destroy_cb, NULL); } TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullOther) @@ -175,7 +175,7 @@ TEST_P(TDMBuffer, BufferRemoveDestroyHandlerNullOther) } static void -_ut_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data) +_tc_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data) { bool *done = (bool*)user_data; if (done) @@ -185,7 +185,7 @@ _ut_tdm_buffer_release_cb(tbm_surface_h buffer, void *user_data) TEST_P(TDMBuffer, BufferAddReleaseHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); @@ -194,14 +194,14 @@ TEST_P(TDMBuffer, BufferAddReleaseHandler) TEST_P(TDMBuffer, BufferAddReleaseHandlerTwice) { - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMBuffer, BufferAddReleaseHandlerNullObject) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_buffer_add_release_handler(NULL, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_INVALID_PARAMETER); ASSERT_EQ(done, false); } @@ -213,10 +213,10 @@ TEST_P(TDMBuffer, BufferAddReleaseHandlerNullOther) TEST_P(TDMBuffer, BufferRemoveReleaseHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); - tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, &done); + tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); ASSERT_EQ(done, false); } @@ -224,41 +224,41 @@ TEST_P(TDMBuffer, BufferRemoveReleaseHandler) TEST_P(TDMBuffer, BufferRemoveReleaseHandlerDifferentData) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); - tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL); + tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL); tdm_buffer_unref_backend(buffer); ASSERT_EQ(done, true); } static void -_ut_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data) +_tc_tdm_buffer_release_cb2(tbm_surface_h buffer, void *user_data) { bool *done = (bool*)user_data; if (done) *done = true; - tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb2, user_data); + tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb2, user_data); } TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); ASSERT_EQ(done, true); done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); ASSERT_EQ(done, true); done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb2, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); tdm_buffer_unref_backend(buffer); @@ -268,10 +268,10 @@ TEST_P(TDMBuffer, BufferRemoveReleaseHandlerInHandler) TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullObject) { bool done = false; - ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _ut_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_buffer_add_release_handler(buffer, _tc_tdm_buffer_release_cb, &done), TDM_ERROR_NONE); tdm_buffer_ref_backend(buffer); ASSERT_EQ(done, false); - tdm_buffer_remove_release_handler(NULL, _ut_tdm_buffer_release_cb, &done); + tdm_buffer_remove_release_handler(NULL, _tc_tdm_buffer_release_cb, &done); tdm_buffer_unref_backend(buffer); ASSERT_EQ(done, true); } @@ -283,7 +283,7 @@ TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNullOther) TEST_P(TDMBuffer, BufferRemoveReleaseHandlerNoAdd) { - tdm_buffer_remove_release_handler(buffer, _ut_tdm_buffer_release_cb, NULL); + tdm_buffer_remove_release_handler(buffer, _tc_tdm_buffer_release_cb, NULL); } #ifdef TDM_UT_TEST_WITH_PARAMS diff --git a/utests/src/ut_tdm_client.cpp b/haltests/src/tc_tdm_client.cpp similarity index 88% rename from utests/src/ut_tdm_client.cpp rename to haltests/src/tc_tdm_client.cpp index e72510a..10e122d 100644 --- a/utests/src/ut_tdm_client.cpp +++ b/haltests/src/tc_tdm_client.cpp @@ -35,7 +35,7 @@ #include #include -#include "ut_tdm.h" +#include "tc_tdm.h" #include "tdm_client.h" /* LCOV_EXCL_START */ @@ -50,9 +50,9 @@ enum { TDM_UT_PIPE_MSG_TERMINATE_SERVER, }; -static int _ut_tdm_pipe_read_msg(int fd); -static bool _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg); -static pid_t _ut_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child); +static int _tc_tdm_pipe_read_msg(int fd); +static bool _tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg); +static pid_t _tc_tdm_client_server_fork(int *pipe_to_parent, int *pipe_to_child); class TDMClient : public TDMEnv { @@ -96,7 +96,7 @@ void TDMClient::ServerFork(void) if (server_pid > 0) return; - server_pid = _ut_tdm_client_server_fork(pipe_parent, pipe_child); + server_pid = _tc_tdm_client_server_fork(pipe_parent, pipe_child); ASSERT_GT(server_pid, 0); } @@ -106,7 +106,7 @@ void TDMClient::ServerKill(void) close(pipe_child[0]); if (pipe_child[1] >= 0) { if (server_pid > 0) { - bool ret = _ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER); + bool ret = _tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_TERMINATE_SERVER); if (ret) { if (waitpid(server_pid, NULL, 0) == server_pid) TDM_INFO("*** server terminated ***"); @@ -200,7 +200,7 @@ bool TDMClient::PrepareVblank(void) } static int -_ut_tdm_pipe_read_msg(int fd) +_tc_tdm_pipe_read_msg(int fd) { ssize_t len; int msg; @@ -216,13 +216,13 @@ _ut_tdm_pipe_read_msg(int fd) } static bool -_ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg) +_tc_tdm_pipe_write_msg(int fd, int reply_fd, int msg) { ssize_t len = write(fd, &msg, sizeof msg); TDM_UT_RETURN_FALSE_IF_FAIL(len == sizeof msg); if (reply_fd >= 0) { - int reply = _ut_tdm_pipe_read_msg(reply_fd); + int reply = _tc_tdm_pipe_read_msg(reply_fd); TDM_UT_RETURN_FALSE_IF_FAIL(reply == TDM_UT_PIPE_MSG_REPLY); } @@ -230,7 +230,7 @@ _ut_tdm_pipe_write_msg(int fd, int reply_fd, int msg) } static bool -_ut_tdm_server_set_output_dpms(tdm_display *dpy, int msg) +_tc_tdm_server_set_output_dpms(tdm_display *dpy, int msg) { tdm_error ret; tdm_output *output; @@ -259,7 +259,7 @@ _ut_tdm_server_set_output_dpms(tdm_display *dpy, int msg) } static void -_ut_tdm_server_run(int *pipe_parent, int *pipe_child) +_tc_tdm_server_run(int *pipe_parent, int *pipe_child) { tdm_display *dpy = NULL; tdm_error ret; @@ -278,13 +278,13 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) TDM_UT_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed); TDM_UT_GOTO_IF_FAIL(output != NULL, failed); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - TDM_UT_GOTO_IF_FAIL(ut_tdm_output_prepare(dpy, output, true) == true, failed); + TDM_UT_GOTO_IF_FAIL(tc_tdm_output_prepare(dpy, output, true) == true, failed); } - TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done); + TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_READY) == true, done); TDM_INFO("*** server ready ***"); @@ -314,16 +314,16 @@ _ut_tdm_server_run(int *pipe_parent, int *pipe_child) } if (fds[0].revents & POLLIN) - ret = ut_tdm_display_handle_events(dpy); + ret = tc_tdm_display_handle_events(dpy); if (fds[1].revents & POLLIN) { - int msg = _ut_tdm_pipe_read_msg(pipe_child[0]); - _ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY); + int msg = _tc_tdm_pipe_read_msg(pipe_child[0]); + _tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_REPLY); switch (msg) { case TDM_UT_PIPE_MSG_DPMS_ON: case TDM_UT_PIPE_MSG_DPMS_OFF: - _ut_tdm_server_set_output_dpms(dpy, msg); + _tc_tdm_server_set_output_dpms(dpy, msg); break; case TDM_UT_PIPE_MSG_TERMINATE_SERVER: goto done; @@ -339,7 +339,7 @@ done: return; failed: - TDM_UT_GOTO_IF_FAIL(_ut_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done); + TDM_UT_GOTO_IF_FAIL(_tc_tdm_pipe_write_msg(pipe_parent[1], -1, TDM_UT_PIPE_MSG_SERVER_FAILED) == true, done); TDM_INFO("*** server failed ***"); if (dpy) @@ -348,7 +348,7 @@ failed: } -static void _ut_tdm_client_sig_handler(int sig) +static void _tc_tdm_client_sig_handler(int sig) { TDM_UT_ERR("got signal: %d", sig); kill(TDMClient::server_pid, 9); @@ -356,7 +356,7 @@ static void _ut_tdm_client_sig_handler(int sig) } static pid_t -_ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child) +_tc_tdm_client_server_fork(int *pipe_parent, int *pipe_child) { pid_t pid; int msg; @@ -365,7 +365,7 @@ _ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child) TDM_UT_GOTO_IF_FAIL(pipe(pipe_child) == 0, failed); signal(SIGCHLD, SIG_IGN); - signal(SIGSEGV, _ut_tdm_client_sig_handler); + signal(SIGSEGV, _tc_tdm_client_sig_handler); prctl(PR_SET_PDEATHSIG, SIGHUP); @@ -373,7 +373,7 @@ _ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child) TDM_UT_GOTO_IF_FAIL(pid >= 0, failed); if (pid == 0) { - _ut_tdm_server_run(pipe_parent, pipe_child); + _tc_tdm_server_run(pipe_parent, pipe_child); close(pipe_child[0]); close(pipe_child[1]); close(pipe_parent[0]); @@ -386,7 +386,7 @@ _ut_tdm_client_server_fork(int *pipe_parent, int *pipe_child) exit(0); } - msg = _ut_tdm_pipe_read_msg(pipe_parent[0]); + msg = _tc_tdm_pipe_read_msg(pipe_parent[0]); TDM_UT_GOTO_IF_FAIL(msg == TDM_UT_PIPE_MSG_SERVER_READY, failed); TDM_INFO("*** server fork done ***"); @@ -455,7 +455,7 @@ TEST_P(TDMClient, ClientGetFdNullOther) } static void -_ut_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) +_tc_tdm_client_vblank_cb(unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { bool *done = (bool *)user_data; if (done) @@ -469,7 +469,7 @@ TEST_P(TDMClient, ClientHandleEvent) ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); ASSERT_EQ(done, false); while (!done) @@ -488,7 +488,7 @@ TEST_P(TDMClient, ClientWaitVblank) ASSERT_EQ(PrepareClient(), true); - ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _ut_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_wait_vblank(client, NULL, 1, 1, 0, _tc_tdm_client_vblank_cb, &done), TDM_ERROR_NONE); ASSERT_EQ(done, false); while (!done) @@ -558,7 +558,7 @@ TEST_P(TDMClient, ClientGetOutputNullOther) } static void -_ut_tdm_client_output_change_dpms_cb(tdm_client_output *output, +_tc_tdm_client_output_change_dpms_cb(tdm_client_output *output, tdm_output_change_type type, tdm_value value, void *user_data) @@ -584,8 +584,8 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) ASSERT_EQ(PrepareClient(), true); ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (!done) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); @@ -593,7 +593,7 @@ TEST_P(TDMClient, ClientOutputAddChangeHandler) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) { ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); @@ -605,13 +605,13 @@ TEST_P(TDMClient, ClientOutputAddChangeHandlerTwice) ASSERT_EQ(PrepareClient(), true); ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullObject) { - ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_output_add_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientOutputAddChangeHandlerNullOther) @@ -628,8 +628,8 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandler) ASSERT_EQ(PrepareClient(), true); ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); - tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL), TDM_ERROR_NONE); + tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL); } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData) @@ -639,19 +639,19 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerDifferentData) ASSERT_EQ(PrepareClient(), true); ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); - tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb, NULL); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb, &done), TDM_ERROR_NONE); + tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb, NULL); } static void -_ut_tdm_client_output_change_dpms_cb2(tdm_client_output *output, +_tc_tdm_client_output_change_dpms_cb2(tdm_client_output *output, tdm_output_change_type type, tdm_value value, void *user_data) { switch (type) { case TDM_OUTPUT_CHANGE_DPMS: - tdm_client_output_remove_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, user_data); + tdm_client_output_remove_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, user_data); break; default: break; @@ -665,22 +665,22 @@ TEST_P(TDMClient, ClientOutputRemoveChangeHandlerInHandler) ASSERT_EQ(PrepareClient(), true); ASSERT_EQ(PrepareOutput(), true); - ASSERT_EQ(tdm_client_output_add_change_handler(output, _ut_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + ASSERT_EQ(tdm_client_output_add_change_handler(output, _tc_tdm_client_output_change_dpms_cb2, NULL), TDM_ERROR_NONE); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); while (dpms != TDM_OUTPUT_DPMS_OFF) { ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullObject) { - tdm_client_output_remove_change_handler(NULL, _ut_tdm_client_output_change_dpms_cb, NULL); + tdm_client_output_remove_change_handler(NULL, _tc_tdm_client_output_change_dpms_cb, NULL); } TEST_P(TDMClient, ClientOutputRemoveChangeHandlerNullOther) @@ -953,7 +953,7 @@ TEST_P(TDMClient, ClientVblankSetEnableFakeNullObject) } static void -_ut_tdm_client_vblank_cb2(tdm_client_vblank *vblank, +_tc_tdm_client_vblank_cb2(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence, unsigned int tv_sec, @@ -975,7 +975,7 @@ TEST_P(TDMClient, ClientVblankWait) ASSERT_EQ(PrepareVblank(), true); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) @@ -995,9 +995,9 @@ TEST_P(TDMClient, ClientVblankWaitFewTime) ASSERT_EQ(PrepareVblank(), true); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) @@ -1015,7 +1015,7 @@ TEST_P(TDMClient, ClientVblankWaitInterval0) ASSERT_EQ(PrepareOutput(), true); ASSERT_EQ(PrepareVblank(), true); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 0, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitInterval) @@ -1029,7 +1029,7 @@ TEST_P(TDMClient, ClientVblankWaitInterval) /* start from 1 */ for (int t = 1; t < 10; t++) { done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, t, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) @@ -1043,7 +1043,7 @@ TEST_P(TDMClient, ClientVblankWaitInterval) } static void -_ut_tdm_client_vblank_cb3(tdm_client_vblank *vblank, +_tc_tdm_client_vblank_cb3(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence, unsigned int tv_sec, @@ -1064,12 +1064,12 @@ TEST_P(TDMClient, ClientVblankWaitSeq) for (int t = 0; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + 1, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); @@ -1089,12 +1089,12 @@ TEST_P(TDMClient, ClientVblankWaitSeqInterval) for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _ut_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait_seq(vblank, cur_seq + t, _tc_tdm_client_vblank_cb3, &temp), TDM_ERROR_NONE); while (temp == 0) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); end = tdm_helper_get_time(); @@ -1116,7 +1116,7 @@ TEST_P(TDMClient, ClientVblankWaitSetOffset) ASSERT_EQ(tdm_client_vblank_set_offset(vblank, 100), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) @@ -1142,7 +1142,7 @@ TEST_P(TDMClient, ClientVblankWaitSetFps) interval = 1.0 / (double)fps; done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done) @@ -1183,12 +1183,12 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[0] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_NE(cur_seq[1], 0); @@ -1203,16 +1203,16 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[0] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_EQ(cur_seq[1], 0); ASSERT_EQ(cur_seq[2], 0); while (cur_seq[1] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_EQ(cur_seq[2], 0); } @@ -1240,12 +1240,12 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[1] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_EQ(cur_seq[0], 0); @@ -1255,7 +1255,7 @@ TEST_P(TDMVblank, VblankWaitIgnoreGlobalFps) ASSERT_LT((end - start), (interval + interval)); while (cur_seq[0] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_NE(cur_seq[2], 0); } @@ -1265,7 +1265,7 @@ TEST_P(TDMClient, ClientVblankWaitNullObject) { unsigned int cur_seq = 0; - ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _ut_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_client_vblank_wait(NULL, 1, _tc_tdm_client_vblank_cb3, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMClient, ClientVblankWaitNullOther) @@ -1285,14 +1285,14 @@ TEST_P(TDMClient, ClientVblankWaitDpmsOff) ASSERT_EQ(PrepareOutput(), true); ASSERT_EQ(PrepareVblank(), true); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); ASSERT_EQ(dpms, TDM_OUTPUT_DPMS_OFF); - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, NULL), TDM_ERROR_DPMS_OFF); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } @@ -1306,19 +1306,19 @@ TEST_P(TDMClient, ClientVblankWaitSetEnableFakeDpmsOff) ASSERT_EQ(PrepareOutput(), true); ASSERT_EQ(PrepareVblank(), true); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_OFF), true); while (dpms != TDM_OUTPUT_DPMS_OFF) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); ASSERT_EQ(tdm_client_vblank_set_enable_fake(vblank, 1), TDM_ERROR_NONE); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); while (!done) ASSERT_EQ(tdm_client_handle_events_timeout(client, 3000), TDM_ERROR_NONE); - ASSERT_EQ(_ut_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); + ASSERT_EQ(_tc_tdm_pipe_write_msg(pipe_child[1], pipe_parent[0], TDM_UT_PIPE_MSG_DPMS_ON), true); while (dpms != TDM_OUTPUT_DPMS_ON) ASSERT_EQ(tdm_client_output_get_dpms(output, &dpms), TDM_ERROR_NONE); } @@ -1334,7 +1334,7 @@ TEST_P(TDMClient, ClientVblankIsWaiting) ASSERT_EQ(PrepareVblank(), true); done = false; - ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _ut_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_client_vblank_wait(vblank, 1, _tc_tdm_client_vblank_cb2, &done), TDM_ERROR_NONE); waiting = tdm_client_vblank_is_waiting(vblank); ASSERT_EQ(waiting, 1); diff --git a/utests/src/ut_tdm_display.cpp b/haltests/src/tc_tdm_display.cpp similarity index 98% rename from utests/src/ut_tdm_display.cpp rename to haltests/src/tc_tdm_display.cpp index 2476999..9ec8ff3 100644 --- a/utests/src/ut_tdm_display.cpp +++ b/haltests/src/tc_tdm_display.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -74,7 +74,7 @@ void TDMDisplay::TearDown(void) } tdm_error -ut_tdm_display_handle_events(tdm_display *dpy) +tc_tdm_display_handle_events(tdm_display *dpy) { struct pollfd fds; int fd = -1; @@ -101,7 +101,7 @@ ut_tdm_display_handle_events(tdm_display *dpy) } bool -ut_tdm_display_has_pp_capability(tdm_display *dpy) +tc_tdm_display_has_pp_capability(tdm_display *dpy) { tdm_display_capability capabilities = (tdm_display_capability)0; TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); @@ -109,7 +109,7 @@ ut_tdm_display_has_pp_capability(tdm_display *dpy) } bool -ut_tdm_display_has_capture_capability(tdm_display *dpy) +tc_tdm_display_has_capture_capability(tdm_display *dpy) { tdm_display_capability capabilities = (tdm_display_capability)0; TDM_UT_RETURN_FALSE_IF_FAIL(tdm_display_get_capabilities(dpy, &capabilities) == TDM_ERROR_NONE); @@ -149,7 +149,7 @@ TEST_P(TDMDisplay, DisplayGetFDNullFD) TEST_P(TDMDisplay, DISABLED_DisplayHandleEvents) { /* TODO Generate events*/ - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } TEST_P(TDMDisplay, DisplayFlush) diff --git a/utests/src/ut_tdm_env.cpp b/haltests/src/tc_tdm_env.cpp similarity index 99% rename from utests/src/ut_tdm_env.cpp rename to haltests/src/tc_tdm_env.cpp index e773e39..398e627 100644 --- a/utests/src/ut_tdm_env.cpp +++ b/haltests/src/tc_tdm_env.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ diff --git a/utests/src/ut_tdm_event_loop.cpp b/haltests/src/tc_tdm_event_loop.cpp similarity index 88% rename from utests/src/ut_tdm_event_loop.cpp rename to haltests/src/tc_tdm_event_loop.cpp index d7f5b6a..d85b1d9 100644 --- a/utests/src/ut_tdm_event_loop.cpp +++ b/haltests/src/tc_tdm_event_loop.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -57,7 +57,7 @@ void TDMEventLoop::TearDown(void) } static tdm_error -_ut_tdm_event_loop_fd_cb(int fd, tdm_event_loop_mask mask, void *user_data) +_tc_tdm_event_loop_fd_cb(int fd, tdm_event_loop_mask mask, void *user_data) { bool *done = (bool*)user_data; if (done) @@ -77,7 +77,7 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandler) done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_READABLE, - _ut_tdm_event_loop_fd_cb, &done, &ret); + _tc_tdm_event_loop_fd_cb, &done, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(source, NULL); @@ -86,7 +86,7 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandler) //TODO // while (!done) -// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -99,7 +99,7 @@ TEST_P(TDMEventLoop, EventLoopAddFdHandlerNullObject) tdm_error ret; tdm_event_loop_source *source; source = tdm_event_loop_add_fd_handler(NULL, 0, TDM_EVENT_LOOP_READABLE, - _ut_tdm_event_loop_fd_cb, NULL, &ret); + _tc_tdm_event_loop_fd_cb, NULL, &ret); ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); ASSERT_EQ(source, NULL); } @@ -125,7 +125,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) done = false; source = tdm_event_loop_add_fd_handler(dpy, pipes[0], TDM_EVENT_LOOP_WRITABLE, - _ut_tdm_event_loop_fd_cb, &done, &ret); + _tc_tdm_event_loop_fd_cb, &done, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(source, NULL); @@ -136,7 +136,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdate) //TODO // while (!done) -// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); @@ -150,7 +150,7 @@ TEST_P(TDMEventLoop, EventLoopSourceFdUpdateNullObject) } static tdm_error -_ut_tdm_event_loop_timer_cb(void *user_data) +_tc_tdm_event_loop_timer_cb(void *user_data) { bool *done = (bool*)user_data; if (done) @@ -162,7 +162,7 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandler) { tdm_error ret; tdm_event_loop_source *source; - source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret); + source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(source, NULL); tdm_event_loop_source_remove(source); @@ -172,7 +172,7 @@ TEST_P(TDMEventLoop, EventLoopAddTimerHandlerNullObject) { tdm_error ret; tdm_event_loop_source *source; - source = tdm_event_loop_add_timer_handler(NULL, _ut_tdm_event_loop_timer_cb, NULL, &ret); + source = tdm_event_loop_add_timer_handler(NULL, _tc_tdm_event_loop_timer_cb, NULL, &ret); ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER); ASSERT_EQ(source, NULL); } @@ -191,13 +191,13 @@ TEST_P(TDMEventLoop, EventLoopSourceTimerUpdate) { tdm_error ret; tdm_event_loop_source *source; - source = tdm_event_loop_add_timer_handler(dpy, _ut_tdm_event_loop_timer_cb, NULL, &ret); + source = tdm_event_loop_add_timer_handler(dpy, _tc_tdm_event_loop_timer_cb, NULL, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(source, NULL); ASSERT_EQ(tdm_event_loop_source_timer_update(source, 100), TDM_ERROR_NONE); //TODO // while (!done) -// ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); +// ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); tdm_event_loop_source_remove(source); } diff --git a/utests/src/ut_tdm_helper.cpp b/haltests/src/tc_tdm_helper.cpp similarity index 96% rename from utests/src/ut_tdm_helper.cpp rename to haltests/src/tc_tdm_helper.cpp index 5aa34b1..4509cd0 100644 --- a/utests/src/ut_tdm_helper.cpp +++ b/haltests/src/tc_tdm_helper.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -396,7 +396,7 @@ TEST_P(TDMHelper, HelperDumpStart) } static void -_ut_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data) +_tc_tdm_helper_capture_cb(tbm_surface_h buffer, void *user_data) { } @@ -412,16 +412,16 @@ TEST_P(TDMHelper, HelperCaptureOutput) ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true); dump = tbm_surface_create(TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, TBM_FORMAT_ARGB8888); ASSERT_NE(dump, NULL); ASSERT_EQ(tdm_helper_capture_output(output, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); + _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_NONE); tdm_helper_dump_buffer_str(dump, NULL, (char*)typeid(*this).name()); @@ -435,7 +435,7 @@ TEST_P(TDMHelper, HelperCaptureOutputNullObject) tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperCaptureOutputNullOther) @@ -451,7 +451,7 @@ TEST_P(TDMHelper, HelperCaptureOutputNullOther) tbm_surface_h dump = (tbm_surface_h)TDM_UT_INVALID_VALUE; ASSERT_EQ(tdm_helper_capture_output(NULL, dump, 0, 0, TDM_UT_BUFFER_SIZE, TDM_UT_BUFFER_SIZE, - _ut_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + _tc_tdm_helper_capture_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMHelper, HelperGetDisplayInformation) @@ -464,9 +464,9 @@ TEST_P(TDMHelper, HelperGetDisplayInformation) tdm_output *output = tdm_display_get_output(dpy, o, &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, output, true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, output, true), true); } tdm_helper_get_display_information(dpy, reply, &len); diff --git a/utests/src/ut_tdm_hwc_window.cpp b/haltests/src/tc_tdm_hwc_window.cpp similarity index 98% rename from utests/src/ut_tdm_hwc_window.cpp rename to haltests/src/tc_tdm_hwc_window.cpp index fb1b190..3af1f35 100644 --- a/utests/src/ut_tdm_hwc_window.cpp +++ b/haltests/src/tc_tdm_hwc_window.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -64,7 +64,7 @@ void TDMHwcWindow::SetUp(void) //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])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { for (int w = 0; w < HWC_WIN_NUM; w++) { hw = tdm_hwc_create_window(outputs[w], &error); ASSERT_EQ(TDM_ERROR_NONE, error); @@ -96,7 +96,7 @@ TEST_P(TDMHwcWindow, DestroyWindowSuccessful) tdm_hwc_window *hw = NULL; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { hw = tdm_hwc_create_window(outputs[o], &error); ASSERT_EQ(TDM_ERROR_NONE, error); error = tdm_hwc_window_destroy(outputs[o], hw); diff --git a/utests/src/ut_tdm_layer.cpp b/haltests/src/tc_tdm_layer.cpp similarity index 77% rename from utests/src/ut_tdm_layer.cpp rename to haltests/src/tc_tdm_layer.cpp index d1eb318..db08461 100644 --- a/utests/src/ut_tdm_layer.cpp +++ b/haltests/src/tc_tdm_layer.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -73,7 +73,7 @@ void TDMLayer::SetUp(void) int old_layer_count = layer_count, count = TDM_UT_INVALID_VALUE; tdm_error ret; - if (ut_tdm_output_is_hwc_enable(outputs[o])) + if (tc_tdm_output_is_hwc_enable(outputs[o])) continue; ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE); @@ -124,7 +124,7 @@ void TDMLayer::DestroyBuffers(void) } bool -ut_tdm_layer_is_cursor_layer(tdm_layer *layer) +tc_tdm_layer_is_cursor_layer(tdm_layer *layer) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) @@ -133,7 +133,7 @@ ut_tdm_layer_is_cursor_layer(tdm_layer *layer) } bool -ut_tdm_layer_is_primary_layer(tdm_layer *layer) +tc_tdm_layer_is_primary_layer(tdm_layer *layer) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) @@ -142,7 +142,7 @@ ut_tdm_layer_is_primary_layer(tdm_layer *layer) } bool -ut_tdm_layer_is_video_layer(tdm_layer *layer) +tc_tdm_layer_is_video_layer(tdm_layer *layer) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) @@ -151,7 +151,7 @@ ut_tdm_layer_is_video_layer(tdm_layer *layer) } bool -ut_tdm_layer_support_scale(tdm_layer *layer) +tc_tdm_layer_support_scale(tdm_layer *layer) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) @@ -160,7 +160,7 @@ ut_tdm_layer_support_scale(tdm_layer *layer) } bool -ut_tdm_layer_support_no_crop(tdm_layer *layer) +tc_tdm_layer_support_no_crop(tdm_layer *layer) { tdm_layer_capability capabilities = (tdm_layer_capability)TDM_UT_INVALID_VALUE; if (tdm_layer_get_capabilities(layer, &capabilities) != TDM_ERROR_NONE) @@ -169,7 +169,7 @@ ut_tdm_layer_support_no_crop(tdm_layer *layer) } unsigned int -ut_tdm_layer_get_output_pipe(tdm_layer *layer) +tc_tdm_layer_get_output_pipe(tdm_layer *layer) { unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE; tdm_error ret; @@ -184,7 +184,7 @@ ut_tdm_layer_get_output_pipe(tdm_layer *layer) } tbm_format -ut_tdm_layer_find_best_format(tdm_layer *layer) +tc_tdm_layer_find_best_format(tdm_layer *layer) { const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; @@ -209,7 +209,7 @@ ut_tdm_layer_find_best_format(tdm_layer *layer) } bool -ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill) +tc_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer_count, bool fill) { tdm_error ret; unsigned int flags = 0; @@ -221,7 +221,7 @@ ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer /* create buffers */ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - format = ut_tdm_layer_find_best_format(layer); + format = tc_tdm_layer_find_best_format(layer); TDM_UT_RETURN_FALSE_IF_FAIL(format != 0); output = tdm_layer_get_output(layer, &ret); @@ -231,7 +231,7 @@ ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL); - if (ut_tdm_layer_is_primary_layer(layer)) { + if (tc_tdm_layer_is_primary_layer(layer)) { w = mode->hdisplay; h = mode->vdisplay; } else { @@ -239,7 +239,7 @@ ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer h = mode->vdisplay / 2; } - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, format, flags | TBM_BO_SCANOUT, fill, buffer_count, buffers) == true); TDM_INFO("preparing buffers done"); @@ -247,7 +247,7 @@ ut_tdm_layer_prepare_buffer(tdm_layer *layer, tbm_surface_h *buffers, int buffer } bool -ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue) +tc_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue) { tdm_error ret; unsigned int flags = 0; @@ -257,10 +257,10 @@ ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_ /* create buffers */ TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_buffer_flags(layer, &flags) == TDM_ERROR_NONE); - format = ut_tdm_layer_find_best_format(layer); + format = tc_tdm_layer_find_best_format(layer); TDM_UT_RETURN_FALSE_IF_FAIL(format != (tbm_format)0); - if (ut_tdm_layer_is_primary_layer(layer)) { + if (tc_tdm_layer_is_primary_layer(layer)) { tdm_output *output; const tdm_output_mode *mode = NULL; output = tdm_layer_get_output(layer, &ret); @@ -286,7 +286,7 @@ ut_tdm_layer_prepare_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_ } bool -ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info) +tc_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue_h buffer_queue, tdm_info_layer *info) { tdm_error ret; tdm_output *output; @@ -324,7 +324,7 @@ ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue bh = mode->vdisplay; w = mode->hdisplay; h = mode->vdisplay; - format = ut_tdm_layer_find_best_format(layer); + format = tc_tdm_layer_find_best_format(layer); } /* TODO: check min,max,prefered size and avaiable formats */ @@ -336,7 +336,7 @@ ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue info->src_config.pos.w = w; info->src_config.pos.h = h; info->src_config.format = format; - if (ut_tdm_layer_is_primary_layer(layer)) { + if (tc_tdm_layer_is_primary_layer(layer)) { info->dst_pos.x = 0; info->dst_pos.y = 0; } else { @@ -354,14 +354,14 @@ ut_tdm_layer_fill_info(tdm_layer *layer, tbm_surface_h buffer, tbm_surface_queue return true; } -bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) +bool tc_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) { tdm_info_layer old_info, info; TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true); if (memcmp(&old_info, &info, sizeof info)) { TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); @@ -388,7 +388,7 @@ bool ut_tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) return true; } -bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos) +bool tc_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, tdm_pos *pos) { tdm_info_layer old_info, info; @@ -396,7 +396,7 @@ bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, td TDM_UT_RETURN_FALSE_IF_FAIL(pos != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, buffer, NULL, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, buffer, NULL, &info) == true); info.dst_pos.x = pos->x; info.dst_pos.y = pos->y; @@ -428,14 +428,14 @@ bool ut_tdm_layer_set_buffer_with_pos(tdm_layer *layer, tbm_surface_h buffer, td return true; } -bool ut_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) +bool tc_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) { tdm_info_layer old_info, info; TDM_UT_RETURN_FALSE_IF_FAIL(buffer_queue != NULL); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_get_info(layer, &old_info) == TDM_ERROR_NONE); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_fill_info(layer, NULL, buffer_queue, &info) == true); if (memcmp(&old_info, &info, sizeof info)) TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_set_info(layer, &info) == TDM_ERROR_NONE); @@ -445,7 +445,7 @@ bool ut_tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_ return true; } -bool ut_tdm_layer_is_avaiable(tdm_layer *layer) +bool tc_tdm_layer_is_avaiable(tdm_layer *layer) { tdm_error ret; tdm_output *output = tdm_layer_get_output(layer, &ret); @@ -453,7 +453,7 @@ bool ut_tdm_layer_is_avaiable(tdm_layer *layer) TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); /* only check if connected */ - return ut_tdm_output_is_connected(output); + return tc_tdm_output_is_connected(output); } TEST_P(TDMLayer, LayerGetOutput) @@ -519,7 +519,7 @@ TEST_P(TDMLayer, LayerGetAvailableFormats) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; const tbm_format *formats = (const tbm_format *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; @@ -543,7 +543,7 @@ TEST_P(TDMLayer, LayerGetAvailableFormatsNullObject) TEST_P(TDMLayer, LayerGetAvailableFormatsNullOther) { TDM_UT_SKIP_FLAG(has_layers); - if (!ut_tdm_layer_is_avaiable(layers[0])) + if (!tc_tdm_layer_is_avaiable(layers[0])) return; ASSERT_EQ(tdm_layer_get_available_formats(layers[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER); } @@ -553,7 +553,7 @@ TEST_P(TDMLayer, LayerGetAvailableProperties) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; int count = TDM_UT_INVALID_VALUE; @@ -590,13 +590,13 @@ TEST_P(TDMLayer, LayerGetZpos) ASSERT_NE(check_table, NULL); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; - unsigned int pipe = ut_tdm_layer_get_output_pipe(layers[l]); + unsigned int pipe = tc_tdm_layer_get_output_pipe(layers[l]); int zpos = TDM_UT_INVALID_VALUE; EXPECT_TRUE(tdm_layer_get_zpos(layers[l], &zpos) == TDM_ERROR_NONE); EXPECT_TRUE(zpos != TDM_UT_INVALID_VALUE); - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; EXPECT_TRUE(zpos >= 0); EXPECT_TRUE(pipe < (unsigned int)output_count); @@ -639,7 +639,7 @@ TEST_P(TDMLayer, LayerGetProperty) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE; @@ -678,14 +678,14 @@ TEST_P(TDMLayer, LayerSetInfo) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; tdm_info_layer info; - ASSERT_EQ(ut_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true); + ASSERT_EQ(tc_tdm_layer_fill_info(layers[l], NULL, NULL, &info), true); ASSERT_EQ(tdm_layer_set_info(layers[l], &info), TDM_ERROR_NONE); } } @@ -731,7 +731,7 @@ TEST_P(TDMLayer, LayerGetBufferFlags) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; unsigned int flags = (unsigned int)TDM_UT_INVALID_VALUE; @@ -757,7 +757,7 @@ TEST_P(TDMLayer, LayerGetBufferFlagsNullOther) } static void -_ut_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence, +_tc_tdm_layer_commit_cb(tdm_layer *layer, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { @@ -772,28 +772,28 @@ TEST_P(TDMLayer, LayerSetBuffer) tdm_error ret; - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 100 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); } @@ -812,31 +812,31 @@ TEST_P(TDMLayer, LayerSetBufferFewTimeInOneCommit) tdm_error ret; - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { tbm_surface_h displaying_buffer = NULL; - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (displaying_buffer != buffers[next_buffer]) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); } @@ -868,10 +868,10 @@ TEST_P(TDMLayer, LayerUnsetBuffer) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -889,29 +889,29 @@ TEST_P(TDMLayer, LayerUnsetBufferBeforeCommit) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ for (int t = 0; t < 10; t++) { - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); if (next_buffer == 3) next_buffer = 0; } @@ -926,26 +926,26 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommit) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -958,28 +958,28 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommit) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -992,30 +992,30 @@ TEST_P(TDMLayer, DISABLED_LayerUnsetBufferAfterTwoCommitOneSetBuffer) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer]), true); ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -1027,32 +1027,32 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDone) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; bool done; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); done = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -1065,37 +1065,37 @@ TEST_P(TDMLayer, LayerUnsetBufferAfterOneCommitOneDoneOneCommit) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; int next_buffer = 0; bool done; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 3, true), true); /* set buffer & commit for 10 times */ - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); done = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); while (!done) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[next_buffer++]), true); next_buffer = 0; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done), TDM_ERROR_NONE); ASSERT_EQ(tdm_layer_unset_buffer(layers[l]), TDM_ERROR_NONE); @@ -1112,30 +1112,30 @@ TEST_P(TDMLayer, LayerCommitDPMSOff) ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) return; - EXPECT_TRUE(ut_tdm_output_prepare(dpy, output, true) == true); + EXPECT_TRUE(tc_tdm_output_prepare(dpy, output, true) == true); EXPECT_TRUE(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF) == TDM_ERROR_NONE); EXPECT_TRUE(tdm_layer_commit(layers[0], NULL, NULL) == TDM_ERROR_DPMS_OFF); - EXPECT_TRUE(ut_tdm_output_unset(dpy, output) == true); + EXPECT_TRUE(tc_tdm_output_unset(dpy, output) == true); } TEST_P(TDMLayer, LayerCommitNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_commit(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_commit(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerCommitNullOther) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); ASSERT_EQ(tdm_layer_commit(layers[0], NULL, NULL), TDM_ERROR_NONE); } @@ -1160,10 +1160,10 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; tdm_error ret; @@ -1171,25 +1171,25 @@ TEST_P(TDMLayer, LayerRemoveCommitHandler) ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer(layers[l], buffers, 1, true), true); - ASSERT_EQ(ut_tdm_layer_set_buffer(layers[l], buffers[0]), true); + ASSERT_EQ(tc_tdm_layer_set_buffer(layers[l], buffers[0]), true); for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); while (!done1 || done2 || !done3) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1201,10 +1201,10 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; tdm_error ret; @@ -1212,44 +1212,44 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerDifferentData) ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layers[l], _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } } static void -_ut_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence, +_tc_tdm_layer_commit_cb2(tdm_layer *layer, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { bool *done = (bool*)user_data; if (done) *done = true; - ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _ut_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_remove_commit_handler(layer, _tc_tdm_layer_commit_cb2, user_data), TDM_ERROR_NONE); } TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; tdm_error ret; @@ -1257,20 +1257,20 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerInHandler) ASSERT_EQ(ret, TDM_ERROR_NONE); ASSERT_NE(output, NULL); - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; for (int t = 0; t < 10; t++) { bool done1 = false, done2 = false, done3 = false; - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_layer_commit(layers[l], _ut_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_layer_commit(layers[l], _tc_tdm_layer_commit_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1280,7 +1280,7 @@ TEST_P(TDMLayer, LayerRemoveCommitHandlerNullObject) { TDM_UT_SKIP_FLAG(has_layers); - ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _ut_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_layer_remove_commit_handler(NULL, _tc_tdm_layer_commit_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMLayer, LayerRemoveCommitHandlerNullOther) @@ -1325,26 +1325,26 @@ TEST_P(TDMLayer, LayerSetBufferQueue) tdm_error ret; - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; tbm_surface_h buffer; tbm_surface_h displaying_buffer; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - if (ut_tdm_layer_is_primary_layer(layers[l])) + if (tc_tdm_layer_is_primary_layer(layers[l])) continue; - ASSERT_EQ(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true); + ASSERT_EQ(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue), true); ASSERT_NE(buffer_queue, NULL); - ASSERT_EQ(ut_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true); + ASSERT_EQ(tc_tdm_layer_set_buffer_queue(layers[l], buffer_queue), true); ASSERT_EQ(tdm_layer_commit(layers[l], NULL, NULL), TDM_ERROR_NONE); @@ -1356,7 +1356,7 @@ TEST_P(TDMLayer, LayerSetBufferQueue) displaying_buffer = NULL; while (displaying_buffer != buffer) { - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); displaying_buffer = tdm_layer_get_displaying_buffer(layers[l], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); } @@ -1372,24 +1372,24 @@ TEST_P(TDMLayer, LayerSetBufferQueueTwice) { TDM_UT_SKIP_FLAG(has_layers); - ut_tdm_output_prepare_all_output(dpy, outputs, output_count, true); + tc_tdm_output_prepare_all_output(dpy, outputs, output_count, true); for (int l = 0; l < layer_count; l++) { tbm_surface_queue_h buffer_queue1 = NULL; tbm_surface_queue_h buffer_queue2 = NULL; - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; - if (ut_tdm_layer_is_cursor_layer(layers[l])) + if (tc_tdm_layer_is_cursor_layer(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; - EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true); + EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue1) == true); EXPECT_TRUE(buffer_queue1 != NULL); EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue1) == TDM_ERROR_NONE); - EXPECT_TRUE(ut_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true); + EXPECT_TRUE(tc_tdm_layer_prepare_buffer_queue(layers[l], &buffer_queue2) == true); EXPECT_TRUE(buffer_queue2 != NULL); EXPECT_TRUE(tdm_layer_set_buffer_queue(layers[l], buffer_queue2) == TDM_ERROR_NONE); @@ -1435,10 +1435,10 @@ TEST_P(TDMLayer, LayerSetVideoPos) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; ++l) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; - if (!ut_tdm_layer_is_video_layer(layers[l])) + if (!tc_tdm_layer_is_video_layer(layers[l])) continue; ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_NONE); } @@ -1456,10 +1456,10 @@ TEST_P(TDMLayer, LayerSetVideoPosNoVideoLayer) TDM_UT_SKIP_FLAG(has_layers); for (int l = 0; l < layer_count; ++l) { - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; - if (ut_tdm_layer_is_video_layer(layers[l])) + if (tc_tdm_layer_is_video_layer(layers[l])) continue; ASSERT_EQ(tdm_layer_set_video_pos(layers[l], -1), TDM_ERROR_BAD_REQUEST); @@ -1474,7 +1474,7 @@ TEST_P(TDMLayer, LayerCreateCapture) tdm_error ret; tdm_capture *capture; - if (!ut_tdm_layer_is_avaiable(layers[l])) + if (!tc_tdm_layer_is_avaiable(layers[l])) continue; capture = tdm_layer_create_capture(layers[l], &ret); diff --git a/utests/src/ut_tdm_log.cpp b/haltests/src/tc_tdm_log.cpp similarity index 72% rename from utests/src/ut_tdm_log.cpp rename to haltests/src/tc_tdm_log.cpp index e399742..e5d6026 100644 --- a/utests/src/ut_tdm_log.cpp +++ b/haltests/src/tc_tdm_log.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -38,10 +38,10 @@ TEST(TDMLog, logPrintf) tdm_log_enable_dlog(0); tdm_log_set_debug_level(2); tdm_log_set_path("/tmp/tdm.log"); - tdm_log_print(TDM_LOG_LEVEL_ERR, "utest\n"); - tdm_log_print(TDM_LOG_LEVEL_WRN, "utest\n"); - tdm_log_print(TDM_LOG_LEVEL_INFO, "utest\n"); - tdm_log_print(TDM_LOG_LEVEL_DBG, "utest\n"); + tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest\n"); + tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest\n"); + tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest\n"); + tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest\n"); tdm_log_set_path(NULL); } @@ -58,34 +58,34 @@ TEST(TDMLog, logDlogNone) tdm_log_enable_color(0); tdm_log_enable_dlog(1); tdm_log_set_debug_level(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"); - tdm_log_print(TDM_LOG_LEVEL_DBG, "utest"); + tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest"); } TEST(TDMLog, logDlog) { tdm_log_enable_dlog(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"); - tdm_log_print(TDM_LOG_LEVEL_DBG, "utest"); + tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest"); } TEST(TDMLog, logDlogNormal) { tdm_log_enable_dlog(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"); - tdm_log_print(TDM_LOG_LEVEL_DBG, "utest"); + tdm_log_print(TDM_LOG_LEVEL_ERR, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_WRN, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_INFO, "haltest"); + tdm_log_print(TDM_LOG_LEVEL_DBG, "haltest"); } TEST(TDMLog, logDlogUnknownLevel) { tdm_log_enable_dlog(1); - tdm_log_print(TDM_UT_INVALID_VALUE, "utest"); + tdm_log_print(TDM_UT_INVALID_VALUE, "haltest"); } /* LCOV_EXCL_END */ \ No newline at end of file diff --git a/utests/src/ut_tdm_main.cpp b/haltests/src/tc_tdm_main.cpp similarity index 98% rename from utests/src/ut_tdm_main.cpp rename to haltests/src/tc_tdm_main.cpp index bc1b1bc..025a1b1 100644 --- a/utests/src/ut_tdm_main.cpp +++ b/haltests/src/tc_tdm_main.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ diff --git a/utests/src/ut_tdm_output.cpp b/haltests/src/tc_tdm_output.cpp similarity index 81% rename from utests/src/ut_tdm_output.cpp rename to haltests/src/tc_tdm_output.cpp index 2559517..15224f0 100644 --- a/utests/src/ut_tdm_output.cpp +++ b/haltests/src/tc_tdm_output.cpp @@ -28,12 +28,12 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ -static void _ut_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); -static void _ut_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); +static void _tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); +static void _tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data); TDMOutput::TDMOutput() { @@ -72,11 +72,11 @@ void TDMOutput::TearDown(void) { if (outputs) { for (int o = 0; o < output_count; o++) { - ASSERT_EQ(ut_tdm_output_unset(dpy, outputs[o]), true); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done3); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); + ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done3); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL); } free(outputs); } @@ -85,7 +85,7 @@ void TDMOutput::TearDown(void) } bool -ut_tdm_output_mode_setting(tdm_output *output) +tc_tdm_output_mode_setting(tdm_output *output) { const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; const tdm_output_mode *found = NULL; @@ -118,7 +118,7 @@ ut_tdm_output_mode_setting(tdm_output *output) } bool -ut_tdm_output_is_async_dpms_enable(tdm_output *output) +tc_tdm_output_is_async_dpms_enable(tdm_output *output) { tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE; if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE) @@ -127,7 +127,7 @@ ut_tdm_output_is_async_dpms_enable(tdm_output *output) } bool -ut_tdm_output_is_hwc_enable(tdm_output *output) +tc_tdm_output_is_hwc_enable(tdm_output *output) { tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE; if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE) @@ -136,7 +136,7 @@ ut_tdm_output_is_hwc_enable(tdm_output *output) } bool -ut_tdm_output_is_aod_enable(tdm_output *output) +tc_tdm_output_is_aod_enable(tdm_output *output) { tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE; if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE) @@ -145,7 +145,7 @@ ut_tdm_output_is_aod_enable(tdm_output *output) } bool -ut_tdm_output_is_connected(tdm_output *output) +tc_tdm_output_is_connected(tdm_output *output) { tdm_output_conn_status status; if (tdm_output_get_conn_status(output, &status) != TDM_ERROR_NONE) @@ -154,7 +154,7 @@ ut_tdm_output_is_connected(tdm_output *output) } tdm_layer * -ut_tdm_output_get_primary_layer(tdm_output *output) +tc_tdm_output_get_primary_layer(tdm_output *output) { tdm_error ret; tdm_layer *layer; @@ -171,7 +171,7 @@ ut_tdm_output_get_primary_layer(tdm_output *output) } static void -_ut_tdm_output_done_cb(tdm_output *output, unsigned int sequence, +_tc_tdm_output_done_cb(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { @@ -181,7 +181,7 @@ _ut_tdm_output_done_cb(tdm_output *output, unsigned int sequence, } bool -ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) +tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) { tbm_surface_h buffer = NULL; tdm_error ret; @@ -190,8 +190,8 @@ ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) bool done = false; tdm_output_conn_status status; - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_is_connected(output) == true); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_mode_setting(output) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_is_connected(output) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE); @@ -201,10 +201,10 @@ ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL); - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true); TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL); - TDM_UT_GOTO_IF_FAIL(ut_tdm_layer_set_buffer(layer, buffer) == true, failed); + TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed); if (tdm_helper_output_commit_per_vblank_enabled(output)) TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed); @@ -215,8 +215,8 @@ ut_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill) TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed); while (!done) { - TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _ut_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed); - TDM_UT_GOTO_IF_FAIL(ut_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _tc_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed); + TDM_UT_GOTO_IF_FAIL(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed); } tbm_surface_internal_unref(buffer); @@ -229,19 +229,19 @@ failed: } bool -ut_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill) +tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - if (!ut_tdm_output_prepare(dpy, outputs[o], fill)) + if (!tc_tdm_output_prepare(dpy, outputs[o], fill)) return false; } return true; } bool -ut_tdm_output_unset(tdm_display *dpy, tdm_output *output) +tc_tdm_output_unset(tdm_display *dpy, tdm_output *output) { tdm_error ret; int count = 0; @@ -255,9 +255,9 @@ ut_tdm_output_unset(tdm_display *dpy, tdm_output *output) TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE); TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL); - if (ut_tdm_layer_is_cursor_layer(layer)) + if (tc_tdm_layer_is_cursor_layer(layer)) continue; - if (ut_tdm_layer_is_video_layer(layer)) + if (tc_tdm_layer_is_video_layer(layer)) continue; TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE); @@ -272,7 +272,7 @@ ut_tdm_output_unset(tdm_display *dpy, tdm_output *output) /* msec */ double -ut_tdm_output_get_vblank_interval_time(tdm_output *output) +tc_tdm_output_get_vblank_interval_time(tdm_output *output) { const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; tdm_error ret = tdm_output_get_mode(output, &mode); @@ -435,7 +435,7 @@ TEST_P(TDMOutput, OutputGetLayerCount) for (int o = 0; o < output_count; o++) { int count = TDM_UT_INVALID_VALUE; - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST); ASSERT_EQ(count, 0); } else { @@ -470,7 +470,7 @@ TEST_P(TDMOutput, OutputGetLayer) tdm_layer *layer; int layer_count = TDM_UT_INVALID_VALUE; - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST); ASSERT_EQ(layer_count, 0); @@ -505,7 +505,7 @@ TEST_P(TDMOutput, OutputGetLayerNullOther) TDM_UT_SKIP_FLAG(has_outputs); tdm_layer *layer; - if (ut_tdm_output_is_hwc_enable(outputs[0])) { + if (tc_tdm_output_is_hwc_enable(outputs[0])) { layer = tdm_output_get_layer(outputs[0], 0, NULL); ASSERT_EQ(layer, NULL); } else { @@ -551,7 +551,7 @@ TEST_P(TDMOutput, OutputGetAvailableModes) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; int count = TDM_UT_INVALID_VALUE; @@ -585,7 +585,7 @@ TEST_P(TDMOutput, OutputGetAvailableSize) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE; @@ -864,7 +864,7 @@ TEST_P(TDMOutput, OutputGetPropertyNullOther) } static void -_ut_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data) +_tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data) { bool *done = (bool *)user_data; if (done) @@ -876,15 +876,15 @@ TEST_P(TDMOutput, OutputAddChangeHandler) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); ASSERT_EQ(done1, true); } @@ -894,15 +894,15 @@ TEST_P(TDMOutput, OutputAddChangeHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _ut_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMOutput, OutputAddChangeHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_add_change_handler(NULL, _ut_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputAddChangeHandlerNullOther) @@ -918,8 +918,8 @@ TEST_P(TDMOutput, OutputRemoveChangeHandler) for (int o = 0; o < output_count; o++) { for (int t = 0; t < 10; t++) { - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL), TDM_ERROR_NONE); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL); } } } @@ -929,14 +929,14 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, NULL); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); ASSERT_EQ(done1, true); @@ -944,12 +944,12 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData) } static void -_ut_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data) +_tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data) { bool *done = (bool*)user_data; if (done) *done = true; - tdm_output_remove_change_handler(output, _ut_tdm_output_change_cb2, user_data); + tdm_output_remove_change_handler(output, _tc_tdm_output_change_cb2, user_data); } TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler) @@ -957,23 +957,23 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); done1 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); ASSERT_EQ(done1, true); done2 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); ASSERT_EQ(done2, true); done3 = false; - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb2, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); ASSERT_EQ(done3, true); } @@ -983,7 +983,7 @@ TEST_P(TDMOutput, OutputRemoveChangeHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_output_remove_change_handler(NULL, _ut_tdm_output_change_cb, NULL); + tdm_output_remove_change_handler(NULL, _tc_tdm_output_change_cb, NULL); } TEST_P(TDMOutput, OutputRemoveChangeHandlerNullOther) @@ -1000,7 +1000,7 @@ TEST_P(TDMOutput, OutputSetMode) for (int o = 0; o < output_count; o++) { const tdm_output_mode *modes; int count; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); @@ -1025,7 +1025,7 @@ TEST_P(TDMOutput, OutputSetModeNullOther) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER); @@ -1040,7 +1040,7 @@ TEST_P(TDMOutput, OutputGetMode) const tdm_output_mode *modes; int count; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE); @@ -1088,14 +1088,14 @@ TEST_P(TDMOutput, OutputSetDpms) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); - if (ut_tdm_output_is_aod_enable(outputs[o])) { + if (tc_tdm_output_is_aod_enable(outputs[o])) { ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); } else { ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST); @@ -1123,18 +1123,18 @@ TEST_P(TDMOutput, OutputSetDpmsAsync) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - if (!ut_tdm_output_is_async_dpms_enable(outputs[o])) + if (!tc_tdm_output_is_async_dpms_enable(outputs[o])) continue; done1 = false; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); - tdm_output_remove_change_handler(outputs[o], _ut_tdm_output_change_cb, &done1); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1); } } @@ -1145,7 +1145,7 @@ TEST_P(TDMOutput, OutputGetDpms) for (int o = 0; o < output_count; o++) { tdm_output_dpms dpms_value; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); @@ -1164,7 +1164,7 @@ TEST_P(TDMOutput, OutputGetDpms) ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON); - if (ut_tdm_output_is_aod_enable(outputs[o])) { + if (tc_tdm_output_is_aod_enable(outputs[o])) { ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE); ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD); @@ -1195,21 +1195,21 @@ TEST_P(TDMOutput, OutputWaitVblank) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1222,7 +1222,7 @@ TEST_P(TDMOutput, OutputWaitVblankNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankNullOther) @@ -1230,10 +1230,10 @@ TEST_P(TDMOutput, OutputWaitVblankNullOther) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE); } @@ -1244,15 +1244,15 @@ TEST_P(TDMOutput, OutputWaitVblankTimeout) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE); usleep(1100000); - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0); } @@ -1262,7 +1262,7 @@ TEST_P(TDMOutput, OutputWaitVblankInterval0) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputWaitVblankInterval) @@ -1270,22 +1270,22 @@ TEST_P(TDMOutput, OutputWaitVblankInterval) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { double start, end, interval; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1300,25 +1300,25 @@ TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { double start, end, interval; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); start = tdm_helper_get_time(); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1333,19 +1333,19 @@ 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])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], false), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true); for (int t = 0; t < 10; t++) { bool done = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _ut_tdm_output_done_cb, &done), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE); if (t == 9) ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while (!done) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1355,20 +1355,20 @@ TEST_P(TDMOutput, OutputRemoveVblankHandler) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); - tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, &done2); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1378,33 +1378,33 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ut_tdm_output_prepare(dpy, outputs[o], true); + tc_tdm_output_prepare(dpy, outputs[o], true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); - tdm_output_remove_vblank_handler(outputs[o], _ut_tdm_output_done_cb, NULL); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } static void -_ut_tdm_output_done_cb2(tdm_output *output, unsigned int sequence, +_tc_tdm_output_done_cb2(tdm_output *output, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { bool *done = (bool*)user_data; if (done) *done = true; - tdm_output_remove_commit_handler(output, _ut_tdm_output_done_cb2, user_data); + tdm_output_remove_commit_handler(output, _tc_tdm_output_done_cb2, user_data); } TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler) @@ -1412,19 +1412,19 @@ TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler) TDM_UT_SKIP_FLAG(has_outputs); for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); /* start from 1 */ for (int t = 1; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1438,21 +1438,21 @@ TEST_P(TDMOutput, OutputCommit) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { double start, end, interval; - interval = ut_tdm_output_get_vblank_interval_time(outputs[o]); + interval = tc_tdm_output_get_vblank_interval_time(outputs[o]); done1 = false; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1465,7 +1465,7 @@ TEST_P(TDMOutput, OutputCommitNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_output_commit(NULL, 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMOutput, OutputCommitNullOther) @@ -1477,7 +1477,7 @@ TEST_P(TDMOutput, OutputCommitNullOther) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE); @@ -1494,14 +1494,14 @@ TEST_P(TDMOutput, OutputCommitDpmsSuspend) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1514,14 +1514,14 @@ TEST_P(TDMOutput, OutputCommitDpmsOff) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1534,21 +1534,21 @@ TEST_P(TDMOutput, OutputCommitDpmsAOD) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - if (!ut_tdm_output_is_aod_enable(outputs[o])) + if (!tc_tdm_output_is_aod_enable(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE); for (int t = 0; t < 10; t++) { done1 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); while (!done1) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1562,10 +1562,10 @@ TEST_P(TDMOutput, OutputCommitAfterLayerCommit) tdm_layer *layer; tdm_error ret; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE); ASSERT_NE(index, TDM_UT_INVALID_VALUE); @@ -1603,18 +1603,18 @@ TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1634,19 +1634,19 @@ TEST_P(TDMOutput, OutputRemoveCommitHandler) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); - tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, &done2); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2); while (!done1 || done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1660,19 +1660,19 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb, &done3), TDM_ERROR_NONE); - tdm_output_remove_commit_handler(outputs[o], _ut_tdm_output_done_cb, NULL); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE); + tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } @@ -1686,18 +1686,18 @@ TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler) if (tdm_helper_output_commit_per_vblank_enabled(outputs[o])) continue; - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - ASSERT_EQ(ut_tdm_output_prepare(dpy, outputs[o], true), true); + ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true); for (int t = 0; t < 10; t++) { done1 = done2 = done3 = false; - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done2), TDM_ERROR_NONE); - ASSERT_EQ(tdm_output_commit(outputs[o], 0, _ut_tdm_output_done_cb2, &done3), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE); while (!done1 || !done2 || !done3) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } } diff --git a/utests/src/ut_tdm_output_hwc.cpp b/haltests/src/tc_tdm_output_hwc.cpp similarity index 96% rename from utests/src/ut_tdm_output_hwc.cpp rename to haltests/src/tc_tdm_output_hwc.cpp index 29019c5..3a6ca4d 100644 --- a/utests/src/ut_tdm_output_hwc.cpp +++ b/haltests/src/tc_tdm_output_hwc.cpp @@ -28,7 +28,7 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ @@ -74,7 +74,7 @@ TEST_P(TDMOutputHwc, CreateWindowSuccessful) tdm_hwc_window * hw = NULL; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { hw = tdm_hwc_create_window(hwc[o], &error); ASSERT_EQ(TDM_ERROR_NONE, error); tdm_hwc_window_destroy(hw); @@ -123,7 +123,7 @@ TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulSetBuff) 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])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_set_client_target_buffer(outputs[o], target_buff, damage, NULL, 0); tbm_surface_internal_destroy(target_buff); @@ -144,7 +144,7 @@ TEST_P(TDMOutputHwc, SetClientTargetBufferSuccessfulResetBuff) tdm_region damage = {.num_rects = 0, .rects = NULL}; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_set_client_target_buffer(outputs[o], NULL, damage, NULL, 0); ASSERT_EQ(TDM_ERROR_NONE, error); @@ -194,7 +194,7 @@ TEST_P(TDMOutputHwc, GetTargetBufferQueueSuccessful) tbm_surface_queue_h queue = NULL; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { queue = tdm_hwc_get_client_target_buffer_queue(outputs[o], &error); tbm_surface_queue_destroy(queue); ASSERT_EQ(TDM_ERROR_NONE, error); @@ -251,7 +251,7 @@ TEST_P(TDMOutputHwc, ValidateSuccessful) uint32_t num_types; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_validate(outputs[o], &num_types); ASSERT_EQ(TDM_ERROR_NONE, error); } else { @@ -311,7 +311,7 @@ TEST_P(TDMHwcWindow, GetChangedCompositionTypesSuccessful) for (int i = 0; i < output_count; i++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_validate(outputs[o], &validate_num); ASSERT_EQ(TDM_ERROR_NONE, error); @@ -367,7 +367,7 @@ TEST_P(TDMHwcWindow, AcceptChangesSuccessful) } for (int i = 0; i < output_count; i++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_validate(outputs[o], &validate_num); ASSERT_EQ(TDM_ERROR_NONE, error); @@ -401,7 +401,7 @@ TEST_P(TDMOutputHwc, GetVideoSupportedFormatsSuccessful) int count; for (int o = 0; o < output_count; o++) { - if (ut_tdm_output_is_hwc_enable(outputs[o])) { + if (tc_tdm_output_is_hwc_enable(outputs[o])) { error = tdm_hwc_get_supported_formats(outputs[o], &formats, &count); if (error != TDM_ERROR_NOT_IMPLEMENTED) { ASSERT_EQ(TDM_ERROR_NONE, error); diff --git a/utests/src/ut_tdm_vblank.cpp b/haltests/src/tc_tdm_vblank.cpp similarity index 86% rename from utests/src/ut_tdm_vblank.cpp rename to haltests/src/tc_tdm_vblank.cpp index 5a6584c..07e97ba 100644 --- a/utests/src/ut_tdm_vblank.cpp +++ b/haltests/src/tc_tdm_vblank.cpp @@ -28,12 +28,12 @@ * **************************************************************************/ -#include "ut_tdm.h" +#include "tc_tdm.h" /* LCOV_EXCL_START */ -static void _ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data); -static void _ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data); +static void _tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data); +static void _tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data); class TDMVblank : public TDMOutput { @@ -71,10 +71,10 @@ void TDMVblank::SetUp(void) void TDMVblank::TearDown(void) { - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, this); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb2, NULL); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, this); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb2, NULL); TestDestroyVblanks(); @@ -116,7 +116,7 @@ bool TDMVblank::TestCreateVblanks3(void) vblank_count = 0; for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; vblank_count = 3; @@ -156,16 +156,16 @@ void TDMVblank::TestDestroyVblanks(void) bool TDMVblank::TestPrepareOutput(void) { for (int o = 0; o < output_count; o++) { - if (!ut_tdm_output_is_connected(outputs[o])) + if (!tc_tdm_output_is_connected(outputs[o])) continue; - TDM_UT_RETURN_FALSE_IF_FAIL(ut_tdm_output_prepare(dpy, outputs[o], false) == true); + TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare(dpy, outputs[o], false) == true); } return true; } -bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank) +bool tc_tdm_vblank_is_avaiable(tdm_vblank *vblank) { tdm_error ret; tdm_output *output = tdm_vblank_get_output(vblank, &ret); @@ -173,13 +173,13 @@ bool ut_tdm_vblank_is_avaiable(tdm_vblank *vblank) TDM_UT_RETURN_FALSE_IF_FAIL(output != NULL); /* only check if connected */ - return ut_tdm_output_is_connected(output); + return tc_tdm_output_is_connected(output); } /* tdm_vblank_set_client_vblank_fps */ TEST_P(TDMVblank, DISABLED_VblankSetClientVblankFps) { - /* tested in ut_tdm_client.c */ + /* tested in tc_tdm_client.c */ } TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject) @@ -191,7 +191,7 @@ TEST_P(TDMVblank, VblankSetClientVblankFpsNullObject) /* tdm_vblank_set_client_vblank_fps */ TEST_P(TDMVblank, DISABLED_VblankSetClientIgnoreGlobalFps) { - /* tested in ut_tdm_client.c */ + /* tested in tc_tdm_client.c */ } TEST_P(TDMVblank, VblankSetClientIgnoreGlobalFpsNullObject) @@ -252,7 +252,7 @@ TEST_P(TDMVblank, VblankDestroyNullObject) } static void -_ut_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data) +_tc_tdm_vblank_create_cb(tdm_vblank *vblank, void *user_data) { TDMVblank *test_vblank = (TDMVblank*)user_data; if (test_vblank) @@ -264,7 +264,7 @@ TEST_P(TDMVblank, VblankAddCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -284,15 +284,15 @@ TEST_P(TDMVblank, VblankAddCreateHandlerTwice) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_BAD_REQUEST); } TEST_P(TDMVblank, VblankAddCreateHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_add_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankAddCreateHandlerNullOther) @@ -307,8 +307,8 @@ TEST_P(TDMVblank, VblankRemoveCreateHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -328,11 +328,11 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerFewTimes) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, this); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, this); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -352,9 +352,9 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb, this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb, this), TDM_ERROR_NONE); - tdm_vblank_remove_create_handler(dpy, _ut_tdm_vblank_create_cb, NULL); + tdm_vblank_remove_create_handler(dpy, _tc_tdm_vblank_create_cb, NULL); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -371,18 +371,18 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerDifferentData) } static void -_ut_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data) +_tc_tdm_vblank_create_cb2(tdm_vblank *vblank, void *user_data) { TDMVblank *test_vblank = (TDMVblank*)user_data; test_vblank->done = true; - tdm_vblank_remove_create_handler(test_vblank->dpy, _ut_tdm_vblank_create_cb2, user_data); + tdm_vblank_remove_create_handler(test_vblank->dpy, _tc_tdm_vblank_create_cb2, user_data); } TEST_P(TDMVblank, VblankRemoveCreateHandlerInHandler) { TDM_UT_SKIP_FLAG(has_outputs); - ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _ut_tdm_vblank_create_cb2, this), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_add_create_handler(dpy, _tc_tdm_vblank_create_cb2, this), TDM_ERROR_NONE); for (int o = 0; o < output_count; o++) { tdm_error ret; @@ -405,7 +405,7 @@ TEST_P(TDMVblank, VblankRemoveCreateHandlerNullObject) { TDM_UT_SKIP_FLAG(has_outputs); - tdm_vblank_remove_create_handler(NULL, _ut_tdm_vblank_create_cb, NULL); + tdm_vblank_remove_create_handler(NULL, _tc_tdm_vblank_create_cb, NULL); } TEST_P(TDMVblank, VblankRemoveCreateHandlerNullOther) @@ -645,7 +645,7 @@ TEST_P(TDMVblank, VblankGetFpsNoSet) const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE; tdm_error ret; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -888,7 +888,7 @@ TEST_P(TDMVblank, VblankGetEnableFakeNoSet) } static void -_ut_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence, +_tc_tdm_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec, void *user_data) { unsigned int *cur_seq = (unsigned int *)user_data; @@ -907,7 +907,7 @@ TEST_P(TDMVblank, VblankWait) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -918,9 +918,9 @@ TEST_P(TDMVblank, VblankWait) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -940,7 +940,7 @@ TEST_P(TDMVblank, VblankWaitFewTime) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -952,11 +952,11 @@ TEST_P(TDMVblank, VblankWaitFewTime) cur_seq = seq1 = seq2 = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &seq2), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq1), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &seq2), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); ASSERT_NE(seq1, 0); @@ -975,7 +975,7 @@ TEST_P(TDMVblank, VblankWaitInterval0) ASSERT_EQ(TestPrepareOutput(), true); ASSERT_EQ(TestCreateVblanks(), true); - ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _ut_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_wait(vblanks[0], 0, 0, 0, _tc_tdm_vblank_cb, NULL), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitInterval) @@ -989,7 +989,7 @@ TEST_P(TDMVblank, VblankWaitInterval) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -1001,9 +1001,9 @@ TEST_P(TDMVblank, VblankWaitInterval) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, t, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1024,7 +1024,7 @@ TEST_P(TDMVblank, VblankWaitSeq) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -1034,14 +1034,14 @@ TEST_P(TDMVblank, VblankWaitSeq) for (int t = 0; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1061,7 +1061,7 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -1072,14 +1072,14 @@ TEST_P(TDMVblank, VblankWaitSeqInterval) for (int t = 1; t < 10; t++) { unsigned int cur_seq = 0, temp = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait_seq(vblanks[v], 0, 0, cur_seq + t, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1095,7 +1095,7 @@ TEST_P(TDMVblank, VblankWaitNullObject) unsigned int cur_seq = 0; - ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER); + ASSERT_EQ(tdm_vblank_wait(NULL, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_INVALID_PARAMETER); } TEST_P(TDMVblank, VblankWaitNullOther) @@ -1119,12 +1119,12 @@ TEST_P(TDMVblank, VblankWaitDpmsOff) tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_DPMS_OFF); } } @@ -1141,15 +1141,15 @@ TEST_P(TDMVblank, VblankWaitBeforeDpmsOff) tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &temp), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &temp), TDM_ERROR_NONE); ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); while (temp == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } @@ -1165,17 +1165,17 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDpmsOff) tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - if (!ut_tdm_output_is_connected(output)) + if (!tc_tdm_output_is_connected(output)) continue; ASSERT_EQ(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE); ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_NONE); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } @@ -1191,10 +1191,10 @@ TEST_P(TDMVblank, VblankWaitDisconnectedOutput) tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (ut_tdm_output_is_connected(output)) + if (tc_tdm_output_is_connected(output)) continue; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_OUTPUT_DISCONNECTED); } } @@ -1209,7 +1209,7 @@ TEST_P(TDMVblank, VblankWaitSetOffset) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_set_offset(vblanks[v], 100), TDM_ERROR_NONE); @@ -1222,9 +1222,9 @@ TEST_P(TDMVblank, VblankWaitSetOffset) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ interval" consider the delay of socket communication between kernel and platform */ @@ -1245,7 +1245,7 @@ TEST_P(TDMVblank, VblankWaitSetFps) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval, vrefresh_interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -1260,9 +1260,9 @@ TEST_P(TDMVblank, VblankWaitSetFps) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1283,7 +1283,7 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) unsigned int fps = (unsigned int)TDM_UT_INVALID_VALUE; double start, end, interval; - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; ASSERT_EQ(tdm_vblank_get_fps(vblanks[v], &fps), TDM_ERROR_NONE); @@ -1300,9 +1300,9 @@ TEST_P(TDMVblank, VblankWaitSetFixedFps) unsigned int cur_seq = 0; start = tdm_helper_get_time(); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+ vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1325,7 +1325,7 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) ASSERT_EQ(TestCreateVblanks3(), true); ASSERT_EQ(vblank_count, 3); - if (!ut_tdm_vblank_is_avaiable(vblanks[0])) + if (!tc_tdm_vblank_is_avaiable(vblanks[0])) return; ASSERT_EQ(tdm_vblank_get_fps(vblanks[0], &fps), TDM_ERROR_NONE); @@ -1342,12 +1342,12 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } start = tdm_helper_get_time(); while (cur_seq[2] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); end = tdm_helper_get_time(); /* "+- vrefresh_interval" consider the delay of socket communication between kernel and platform */ @@ -1358,27 +1358,27 @@ TEST_P(TDMVblank, VblankWaitEnableDisableGlobalFps) ASSERT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_EQ(cur_seq[0], 0); while (cur_seq[0] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); /* disable test. global fps doesn't effect server's vblanks */ tdm_vblank_enable_global_fps(0, 0); for (int v = 0; v < 3; v++) { cur_seq[v] = 0; - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq[v]), TDM_ERROR_NONE); } while (cur_seq[2] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_EQ(cur_seq[1], 0); ASSERT_EQ(cur_seq[0], 0); while (cur_seq[1] == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); ASSERT_EQ(cur_seq[0], 0); } @@ -1394,15 +1394,15 @@ TEST_P(TDMVblank, VblankWaitSetEnableFakeDisconnected) tdm_output *output = tdm_vblank_get_output(vblanks[v], &ret); ASSERT_EQ(ret, TDM_ERROR_NONE); - if (!ut_tdm_vblank_is_avaiable(vblanks[v])) + if (!tc_tdm_vblank_is_avaiable(vblanks[v])) continue; - if (ut_tdm_output_is_connected(output)) + if (tc_tdm_output_is_connected(output)) continue; ASSERT_EQ(tdm_vblank_set_enable_fake(vblanks[v], 1), TDM_ERROR_DPMS_OFF); - ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _ut_tdm_vblank_cb, NULL), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblanks[v], 0, 0, 1, _tc_tdm_vblank_cb, NULL), TDM_ERROR_NONE); } } @@ -1422,10 +1422,10 @@ TEST_P(TDMVblank, VblankWaitTimeout) tdm_vblank *vblank = vblanks[0]; unsigned int cur_seq = 0; - ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _ut_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); + ASSERT_EQ(tdm_vblank_wait(vblank, 0, 0, 1, _tc_tdm_vblank_cb, &cur_seq), TDM_ERROR_NONE); usleep(1200000); while (cur_seq == 0) - ASSERT_EQ(ut_tdm_display_handle_events(dpy), TDM_ERROR_NONE); + ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE); } } diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 0e29b11..6c93349 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -1,5 +1,5 @@ -%define UTEST_PACKAGE 1 -%define UTEST_GCOV 0 +%define HALTESTS_PACKAGE 1 +%define HALTESTS_GCOV 0 Name: libtdm Version: 1.18.0 @@ -46,7 +46,7 @@ Requires: libtdm-devel %description client-devel Tizen Display Manager Client Library headers -%if "%{UTEST_PACKAGE}" == "1" +%if "%{HALTESTS_PACKAGE}" == "1" %package haltests Summary: Tizen Display Manager unit tests package Group: Development/Libraries @@ -70,19 +70,19 @@ This contains libtdm tools for fundamental testing cp %{SOURCE1001} . %build -UTEST="no" +HALTESTS="no" -%if "%{UTEST_PACKAGE}" == "1" -UTEST="yes" +%if "%{HALTESTS_PACKAGE}" == "1" +HALTESTS="yes" %endif -%if "%{UTEST_GCOV}" == "1" +%if "%{HALTESTS_GCOV}" == "1" CFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV" CXXFLAGS+=" -fprofile-arcs -ftest-coverage -DTIZEN_TEST_GCOV" LDFLAGS+=" -lgcov" %endif -%reconfigure --disable-static --with-utests=${UTEST} \ +%reconfigure --disable-static --with-haltests=${HALTESTS} \ --with-tdm-data-path=%{TZ_SYS_RO_SHARE}/tdm \ CFLAGS="${CFLAGS} -Wall -Werror" \ CXXFLAGS="${CXXFLAGS} -Wall -Werror" \ @@ -151,10 +151,10 @@ rm -f %{_unitdir_user}/basic.target.wants/tdm-socket-user.path %attr(750,root,root) %{_bindir}/tdm-test-server %{_bindir}/tdm-test-client -%if "%{UTEST_PACKAGE}" == "1" +%if "%{HALTESTS_PACKAGE}" == "1" %files haltests %defattr(-,root,root,-) -%{_bindir}/tdm-utests +%{_bindir}/tdm-haltests %endif %changelog diff --git a/utests/Makefile.am b/utests/Makefile.am deleted file mode 100644 index 7aed5c8..0000000 --- a/utests/Makefile.am +++ /dev/null @@ -1,45 +0,0 @@ -bin_PROGRAMS = tdm-utests - -tdm_utests_SOURCES = \ - src/ut_tdm_main.cpp \ - src/ut_tdm_log.cpp \ - src/ut_tdm_env.cpp \ - src/ut_tdm_event_loop.cpp \ - src/ut_tdm_buffer.cpp \ - src/ut_tdm_helper.cpp \ - src/ut_tdm_vblank.cpp \ - src/ut_tdm_display.cpp \ - src/ut_tdm_output.cpp \ - src/ut_tdm_layer.cpp \ - src/ut_tdm_client.cpp \ - src/ut_tdm_backend_env.cpp \ - src/ut_tdm_backend_display.cpp \ - src/ut_tdm_backend_pp.cpp \ - src/ut_tdm_backend_capture.cpp - -tdm_utests_SOURCES += \ - ../tools/buffers.c - -tdm_utests_CXXFLAGS = \ - $(CXXFLAGS) \ - $(TDM_CFLAGS) \ - -I../src \ - -I../include \ - -I../client \ - -I../tools \ - -I$(includedir)/gtest \ - -fpermissive -# The flag -w is used, because there are many warnings in libtdm's sources. -# Warnings occur because we build project with g++. -# In C++ we need to use explicit types conversion. - -tdm_utests_LDFLAGS = \ - ${LDFLAGS} \ - $(TDM_LIBS) \ - $(top_builddir)/src/libtdm.la \ - $(top_builddir)/client/libtdm-client.la \ - $(top_builddir)/common/libtdm-common.la \ - -lgtest - -check: - ./tdm-utests -- 2.7.4