From 64f82c3d1812f47bf5d04fcb3ea6e801b6098b2c Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Fri, 11 Mar 2016 13:34:12 +0900 Subject: [PATCH 01/16] install the license file Change-Id: I3e4c22abba4ad716e9c4d14cfc1ad1a0e15ead42 --- packaging/libtdm.spec | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index 43d4969..b06652b 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -23,6 +23,8 @@ Requires: pkgconfig(libtbm) %description devel This supports frontend & backend library header and so +%global TZ_SYS_RO_SHARE %{?TZ_SYS_RO_SHARE:%TZ_SYS_RO_SHARE}%{!?TZ_SYS_RO_SHARE:/usr/share} + %prep %setup -q cp %{SOURCE1001} . @@ -34,16 +36,21 @@ cp %{SOURCE1001} . make %{?_smp_mflags} %install +rm -rf %{buildroot} +mkdir -p %{buildroot}/%{TZ_SYS_RO_SHARE}/license +cp -af COPYING %{buildroot}/%{TZ_SYS_RO_SHARE}/license/%{name} %make_install +%remove_docs + %post -p /sbin/ldconfig %postun -p /sbin/ldconfig %files %manifest %{name}.manifest -%license COPYING %defattr(-,root,root,-) +%{TZ_SYS_RO_SHARE}/license/%{name} %{_libdir}/libtdm.so.* %files devel -- 2.7.4 From 66f7ca417b5fbe400b43d52cd8dd21b063c1be1c Mon Sep 17 00:00:00 2001 From: Sangjin Lee Date: Mon, 14 Mar 2016 18:02:56 +0900 Subject: [PATCH 02/16] change deprecated APIs Change-Id: I82daf13d77b949e9bffb8db14df39f1efcda981d --- src/tdm_display.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/tdm_display.c b/src/tdm_display.c index 7f4857a..cbcf675 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -1290,10 +1290,10 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) } private_layer->buffer_queue = buffer_queue; - tbm_surface_queue_set_acquirable_cb(private_layer->buffer_queue, + tbm_surface_queue_add_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer); - tbm_surface_queue_set_destroy_cb(private_layer->buffer_queue, + tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer); pthread_mutex_unlock(&private_display->lock); @@ -1337,8 +1337,8 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer) private_layer, private_layer->showing_buffer); } - tbm_surface_queue_set_acquirable_cb(private_layer->buffer_queue, NULL, NULL); - tbm_surface_queue_set_destroy_cb(private_layer->buffer_queue, NULL, NULL); + tbm_surface_queue_remove_acquirable_cb(private_layer->buffer_queue, _tbm_layer_queue_acquirable_cb, layer); + tbm_surface_queue_remove_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer); private_layer->buffer_queue = NULL; private_layer->usable = 1; -- 2.7.4 From a95dc0ec22ee09e86f1164b1c861087007dadb85 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 16 Mar 2016 17:12:33 +0900 Subject: [PATCH 03/16] map/unmap for dump Change-Id: Ib91a52e7c3dbb95db719da201efe8a0d34a3d999 --- src/tdm_helper.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/tdm_helper.c b/src/tdm_helper.c index dd57986..d4a0937 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -110,13 +110,14 @@ EXTERN void tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) { tbm_surface_info_s info; - int len; + int len, ret; const char *prefix; TDM_RETURN_IF_FAIL(buffer != NULL); TDM_RETURN_IF_FAIL(file != NULL); - tbm_surface_get_info(buffer, &info); + ret = tbm_surface_map(buffer, TBM_DEVICE_CPU, &info); + TDM_RETURN_IF_FAIL(ret == TBM_SURFACE_ERROR_NONE); len = strnlen(file, 1024); if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888) @@ -126,6 +127,7 @@ tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) if (strncmp(file + (len - 3), prefix, 3)) { TDM_ERR("can't dump to '%s' file", file + (len - 3)); + tbm_surface_unmap(buffer); return; } @@ -163,8 +165,11 @@ tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) break; default: TDM_ERR("can't dump %c%c%c%c buffer", FOURCC_STR (info.format)); + tbm_surface_unmap(buffer); return; } + tbm_surface_unmap(buffer); + TDM_INFO("dump %s", file); } -- 2.7.4 From 152309540993deec16594de71fa7bac777d29e67 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 16 Mar 2016 19:06:18 +0900 Subject: [PATCH 04/16] return error if a buffer is attached twice We have to handle attaching a buffer twice as error. Display server should attach a buffer after finishing a previous converting. Change-Id: I98ee0a585af19f3a3009133f99a2c27b4e51b438 --- src/tdm_capture.c | 29 +++++++++++++++++++++++++++++ src/tdm_pp.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+) diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 14ebc3d..133de4b 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -51,6 +51,29 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. private_display = private_capture->private_display; \ func_capture = &private_display->func_capture +static tdm_error +_tdm_capture_check_if_exist(tdm_private_capture *private_capture, + tbm_surface_h buffer) +{ + tdm_buffer_info *buf_info = NULL; + + LIST_FOR_EACH_ENTRY(buf_info, &private_capture->buffer_list, link) { + if (buf_info->buffer == buffer) { + TDM_ERR("%p attached twice", buffer); + return TDM_ERROR_BAD_REQUEST; + } + } + + LIST_FOR_EACH_ENTRY(buf_info, &private_capture->pending_buffer_list, link) { + if (buf_info->buffer == buffer) { + TDM_ERR("%p attached twice", buffer); + return TDM_ERROR_BAD_REQUEST; + } + } + + return TDM_ERROR_NONE; +} + static void _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *user_data) @@ -281,6 +304,12 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) return TDM_ERROR_NONE; } + ret = _tdm_capture_check_if_exist(private_capture, buffer); + if (ret != TDM_ERROR_NONE) { + pthread_mutex_unlock(&private_display->lock); + return ret; + } + ret = func_capture->capture_attach(private_capture->capture_backend, buffer); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); diff --git a/src/tdm_pp.c b/src/tdm_pp.c index 8f43860..ad6f8a5 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -51,6 +51,43 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. private_display = private_pp->private_display; \ func_pp = &private_display->func_pp +static tdm_error +_tdm_pp_check_if_exist(tdm_private_pp *private_pp, + tbm_surface_h src, tbm_surface_h dst) +{ + tdm_buffer_info *buf_info = NULL; + + LIST_FOR_EACH_ENTRY(buf_info, &private_pp->src_buffer_list, link) { + if (buf_info->buffer == src) { + TDM_ERR("%p attached twice", src); + return TDM_ERROR_BAD_REQUEST; + } + } + + LIST_FOR_EACH_ENTRY(buf_info, &private_pp->src_pending_buffer_list, link) { + if (buf_info->buffer == src) { + TDM_ERR("%p attached twice", src); + return TDM_ERROR_BAD_REQUEST; + } + } + + LIST_FOR_EACH_ENTRY(buf_info, &private_pp->dst_buffer_list, link) { + if (buf_info->buffer == dst) { + TDM_ERR("%p attached twice", dst); + return TDM_ERROR_BAD_REQUEST; + } + } + + LIST_FOR_EACH_ENTRY(buf_info, &private_pp->dst_pending_buffer_list, link) { + if (buf_info->buffer == dst) { + TDM_ERR("%p attached twice", dst); + return TDM_ERROR_BAD_REQUEST; + } + } + + return TDM_ERROR_NONE; +} + static void _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, void *user_data) @@ -269,6 +306,12 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) return TDM_ERROR_NONE; } + ret = _tdm_pp_check_if_exist(private_pp, src, dst); + if (ret != TDM_ERROR_NONE) { + pthread_mutex_unlock(&private_display->lock); + return ret; + } + ret = func_pp->pp_attach(private_pp->pp_backend, src, dst); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); -- 2.7.4 From 5c7c66a5a6ee83d0c8ed09cbe6159e2e4fb9d14e Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 17 Mar 2016 09:04:22 +0900 Subject: [PATCH 05/16] fix syntax error Change-Id: I5fdb2e30bb3e0d1c664cfa14d881f067f5c3f04e --- src/tdm_helper.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/tdm_helper.c b/src/tdm_helper.c index d4a0937..7c47b6e 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -140,26 +140,26 @@ tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) case TBM_FORMAT_YVU420: case TBM_FORMAT_YUV420: _tdm_helper_dump_raw(file, - info.planes[0].ptr + info.planes[0].offset, + info.planes[0].ptr, info.planes[0].stride * info.height, - info.planes[1].ptr + info.planes[1].offset, + info.planes[1].ptr, info.planes[1].stride * (info.height >> 1), - info.planes[2].ptr + info.planes[2].offset, + info.planes[2].ptr, info.planes[2].stride * (info.height >> 1)); break; case TBM_FORMAT_NV12: case TBM_FORMAT_NV21: _tdm_helper_dump_raw(file, - info.planes[0].ptr + info.planes[0].offset, + info.planes[0].ptr, info.planes[0].stride * info.height, - info.planes[1].ptr + info.planes[1].offset, + info.planes[1].ptr, info.planes[1].stride * (info.height >> 1), NULL, 0); break; case TBM_FORMAT_YUYV: case TBM_FORMAT_UYVY: _tdm_helper_dump_raw(file, - info.planes[0].ptr + info.planes[0].offset, + info.planes[0].ptr, info.planes[0].stride * info.height, NULL, 0, NULL, 0); break; -- 2.7.4 From 1291e14b597459fc5eb7f6ec19ab09e0a3837b50 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 17 Mar 2016 12:03:06 +0900 Subject: [PATCH 06/16] unref buffer when destroyed Change-Id: I71ed02cfe70569c25b175142c0420387e70825c1 --- src/tdm_capture.c | 13 +++++++++++-- src/tdm_pp.c | 24 ++++++++++++++++++++---- 2 files changed, 31 insertions(+), 6 deletions(-) diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 133de4b..a68739d 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -222,6 +222,7 @@ tdm_capture_create_layer_internal(tdm_private_layer *private_layer, INTERN void tdm_capture_destroy_internal(tdm_private_capture *private_capture) { + tdm_private_display *private_display = private_capture->private_display; tdm_func_capture *func_capture; tdm_buffer_info *b = NULL, *bb = NULL; @@ -237,16 +238,24 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture) TDM_ERR("capture(%p) not finished:", private_capture); tdm_buffer_list_dump(&private_capture->pending_buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } if (!LIST_IS_EMPTY(&private_capture->buffer_list)) { TDM_ERR("capture(%p) not finished:", private_capture); tdm_buffer_list_dump(&private_capture->buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } free(private_capture); diff --git a/src/tdm_pp.c b/src/tdm_pp.c index ad6f8a5..cd88f49 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -211,32 +211,48 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) TDM_ERR("pp(%p) not finished:", private_pp); tdm_buffer_list_dump(&private_pp->src_pending_buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_pending_buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_pending_buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } if (!LIST_IS_EMPTY(&private_pp->dst_pending_buffer_list)) { TDM_ERR("pp(%p) not finished:", private_pp); tdm_buffer_list_dump(&private_pp->dst_pending_buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_pending_buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_pending_buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } if (!LIST_IS_EMPTY(&private_pp->src_buffer_list)) { TDM_ERR("pp(%p) not finished:", private_pp); tdm_buffer_list_dump(&private_pp->src_buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } if (!LIST_IS_EMPTY(&private_pp->dst_buffer_list)) { TDM_ERR("pp(%p) not finished:", private_pp); tdm_buffer_list_dump(&private_pp->dst_buffer_list); - LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_buffer_list, link) + LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_buffer_list, link) { LIST_DEL(&b->link); + pthread_mutex_unlock(&private_display->lock); + tdm_buffer_unref_backend(b->buffer); + pthread_mutex_lock(&private_display->lock); + } } free(private_pp); -- 2.7.4 From dd2dbae510435c393ca931ada29f5fdf3dc55f23 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 17 Mar 2016 13:03:52 +0900 Subject: [PATCH 07/16] fix syntax error Change-Id: If368fcb353e920ecb0f362c52c38c75dead52751 --- src/tdm_buffer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tdm_buffer.c b/src/tdm_buffer.c index 7ab6c21..9de916f 100644 --- a/src/tdm_buffer.c +++ b/src/tdm_buffer.c @@ -83,7 +83,7 @@ _tdm_buffer_destroy_info(void *user_data) free(buf_info); } -tdm_buffer_info * +INTERN tdm_buffer_info * tdm_buffer_get_info(tbm_surface_h buffer) { tdm_buffer_info *buf_info = NULL; -- 2.7.4 From 4494265fbbd8ec7a7bc811c88eb0e5f91a38e4e1 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Thu, 17 Mar 2016 13:58:22 +0900 Subject: [PATCH 08/16] fix doxygen document Change-Id: I588b867d55069ed8199bd24894d85fd51e850e7c --- doc/tdm_doc.h | 28 +++++++++++++++++++--------- include/tdm_backend.h | 14 +++++++------- 2 files changed, 26 insertions(+), 16 deletions(-) diff --git a/doc/tdm_doc.h b/doc/tdm_doc.h index 9652b58..7d4c856 100644 --- a/doc/tdm_doc.h +++ b/doc/tdm_doc.h @@ -39,8 +39,8 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /** * @mainpage TDM * @author Boram Park, boram1288.park@samsung.com - * @date Dec 30, 2015 - * @version 1.0.0 + * @date Mar 17, 2016 + * @version 1.1.0 * @par Introduction * TDM stands for Tizen Display Manager. It's the display HAL layer for tizen * display server. It offers the frontend APIs(@ref tdm.h) for a frontend user @@ -69,20 +69,24 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * A backend module @b SHOULD define the global data symbol of which name is * @b "tdm_backend_module_data". TDM will read this symbol, @b "tdm_backend_module_data", * at the initial time and call init() function of #tdm_backend_module. - * A backend module at least @b SHOULD register the #tdm_func_display functions - * to a display object with #tdm_backend_register_func_display() function in initial time.\n + * A backend module at least @b SHOULD register the #tdm_func_display, + * #tdm_func_output, #tdm_func_layer functions to a display object via + * #tdm_backend_register_func_display(), #tdm_backend_register_func_output(), + * #tdm_backend_register_func_layer() functions in initial time.\n * @code #include - static tdm_func_display drm_func_display = - { + static tdm_func_display drm_func_display = { drm_display_get_capabilitiy, ... - drm_display_get_outputs, - ... + }; + + static tdm_func_output drm_func_output = { drm_output_get_capability, - drm_output_get_layers, ... + }; + + static tdm_func_layer drm_func_layer = { drm_layer_get_capability, ... }; @@ -98,6 +102,12 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ret = tdm_backend_register_func_display(dpy, &drm_func_display); if (ret != TDM_ERROR_NONE) goto failed; + ret = tdm_backend_register_func_output(dpy, &drm_func_output); + if (ret != TDM_ERROR_NONE) + goto failed; + ret = tdm_backend_register_func_layer(dpy, &drm_func_layer); + if (ret != TDM_ERROR_NONE) + goto failed; ... return (tdm_backend_data*)drm_data; } diff --git a/include/tdm_backend.h b/include/tdm_backend.h index 775efcc..bc9d195 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -72,7 +72,7 @@ typedef struct _tdm_caps_display { /** * @brief The capabilities structure of a output object - * @see The output_get_capability() function of #tdm_func_display + * @see The output_get_capability() function of #tdm_func_output */ typedef struct _tdm_caps_output { char maker[TDM_NAME_LEN]; /**< The output maker */ @@ -103,7 +103,7 @@ typedef struct _tdm_caps_output { /** * @brief The capabilities structure of a layer object - * @see The layer_get_capability() function of #tdm_func_display + * @see The layer_get_capability() function of #tdm_func_layer */ typedef struct _tdm_caps_layer { tdm_layer_capability capabilities; /**< The capabilities of layer */ @@ -113,7 +113,7 @@ typedef struct _tdm_caps_layer { * GRAPHIC layers are non-changeable. The zpos of GRAPHIC layers starts * from 0. If there are 4 GRAPHIC layers, The zpos SHOULD be 0, 1, 2, 3.\n * But the zpos of VIDEO layer is changeable by layer_set_video_pos() function - * of #tdm_func_display. And The zpos of VIDEO layers is less than GRAPHIC + * of #tdm_func_layer. And The zpos of VIDEO layers is less than GRAPHIC * layers or more than GRAPHIC layers. * ie, ..., -2, -1, 4, 5, ... (if 0 <= GRAPHIC layer's zpos < 4). * The zpos of VIDEO layers is @b relative. It doesn't need to start @@ -521,7 +521,7 @@ typedef struct _tdm_func_layer { * @param[in] layer A layer object * @param[in] info The geometry information * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @see output_commit() function of #tdm_func_display + * @see output_commit() function of #tdm_func_output * @remark * A backend module would apply the geometry information when the output object * of a layer object is committed. @@ -541,7 +541,7 @@ typedef struct _tdm_func_layer { * @param[in] layer A layer object * @param[in] buffer A TDM buffer * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @see output_commit() function of #tdm_func_display + * @see output_commit() function of #tdm_func_output * @remark * A backend module would apply a TDM buffer when the output object * of a layer object is committed. @@ -689,8 +689,8 @@ typedef struct _tdm_func_capture { /** * @brief Destroy a capture object * @param[in] capture A capture object - * @see output_create_capture() function of #tdm_func_display - * @see layer_create_capture() function of #tdm_func_display + * @see output_create_capture() function of #tdm_func_output + * @see layer_create_capture() function of #tdm_func_layer */ void (*capture_destroy)(tdm_capture *capture); -- 2.7.4 From cc661633abc411e95f6abce78174c22dc57e61ef Mon Sep 17 00:00:00 2001 From: SooChan Lim Date: Wed, 6 Apr 2016 14:24:18 +0900 Subject: [PATCH 09/16] add TDM_LAYER_CAPABILITY_RESERVED_MEMORY Change-Id: I0a67874a6ff3345d83d02b9c325a58e3d4543cd2 --- include/tdm_types.h | 1 + 1 file changed, 1 insertion(+) mode change 100644 => 100755 include/tdm_types.h diff --git a/include/tdm_types.h b/include/tdm_types.h old mode 100644 new mode 100755 index 744e8f0..af69324 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -166,6 +166,7 @@ typedef enum { TDM_LAYER_CAPABILITY_SCALE = (1 << 8), /**< if a layer has scale capability */ TDM_LAYER_CAPABILITY_TRANSFORM = (1 << 9), /**< if a layer has transform capability */ TDM_LAYER_CAPABILITY_SCANOUT = (1 << 10), /**< if a layer allows a scanout buffer only */ + TDM_LAYER_CAPABILITY_RESEVED_MEMORY = (1 << 11), /**< if a layer allows a reserved buffer only */ } tdm_layer_capability; /** -- 2.7.4 From 47d129b17e0e94e997bd4c438c531a8f4f560bda Mon Sep 17 00:00:00 2001 From: Boram Park Date: Tue, 22 Mar 2016 21:55:45 +0900 Subject: [PATCH 10/16] Revert "add display_buffer_get_fd to TDM backend interface" This reverts commit 748a516c6f3f754be4ff0e32d21a0985839cbea1. Conflicts: include/tdm_backend.h src/tdm.c src/tdm_private.h Change-Id: Ida5296ea6fcc210cabb62361d416afca3cfbc691 --- include/tdm_backend.h | 10 ---------- src/tdm.c | 36 ------------------------------------ src/tdm_private.h | 2 -- 3 files changed, 48 deletions(-) diff --git a/include/tdm_backend.h b/include/tdm_backend.h index bc9d195..f240d41 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -288,16 +288,6 @@ typedef struct _tdm_func_display { tdm_error (*display_get_fd)(tdm_backend_data *bdata, int *fd); /** - * @brief Get the file descriptor for the memory-management framework of a backend module - * @param[in] bdata The backend module data - * @param[out] fd The fd of a backend module - * @return #TDM_ERROR_NONE if success. Otherwise, error value. - * @see display_handle_events() function of #tdm_func_display - * This buffer fd will be passed to tbm_bufmgr_init. - */ - tdm_error (*display_get_buffer_fd)(tdm_backend_data *bdata, int *fd); - - /** * @brief Handle the events which happens on the fd of a backend module * @param[in] bdata The backend module data * @return #TDM_ERROR_NONE if success. Otherwise, error value. diff --git a/src/tdm.c b/src/tdm.c index 2933a23..a7451f1 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -451,33 +451,6 @@ failed_update: return ret; } -static tdm_error -_tdm_display_init_bufmgr(tdm_private_display *private_display) -{ - tdm_func_display *func_display = &private_display->func_display; - int buffer_fd = -1; - tdm_error ret; - - if (func_display->display_get_buffer_fd) { - ret = func_display->display_get_buffer_fd(private_display->bdata, &buffer_fd); - if (ret != TDM_ERROR_NONE) { - TDM_ERR("failed to get buffer fd"); - return ret; - } - } - - private_display->bufmgr = tbm_bufmgr_init(buffer_fd); - if (!private_display->bufmgr) { - TDM_ERR("failed to init TBM bufmgr: fd(%d)", buffer_fd); - return TDM_ERROR_OUT_OF_MEMORY; - } - - TDM_INFO("init TBM bufmgr: fd(%d)", buffer_fd); - - return TDM_ERROR_NONE; -} - - EXTERN tdm_error tdm_display_update(tdm_display *dpy) { @@ -764,12 +737,6 @@ tdm_display_init(tdm_error *error) if (ret != TDM_ERROR_NONE) goto failed_update; - TDM_TRACE_BEGIN(Bufmgr_Init); - ret = _tdm_display_init_bufmgr(private_display); - TDM_TRACE_END(); - if (ret != TDM_ERROR_NONE) - goto failed_update; - private_display->init_count = 1; g_private_display = private_display; @@ -814,9 +781,6 @@ tdm_display_deinit(tdm_display *dpy) pthread_mutex_lock(&private_display->lock); - if (private_display->bufmgr) - tbm_bufmgr_deinit(private_display->bufmgr); - _tdm_display_destroy_private_display(private_display); _tdm_display_unload_module(private_display); diff --git a/src/tdm_private.h b/src/tdm_private.h index fb0f7ad..c1a34d0 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -187,8 +187,6 @@ struct _tdm_private_display { struct list_head pp_list; void **outputs_ptr; - - tbm_bufmgr bufmgr; }; struct _tdm_private_output { -- 2.7.4 From ff74e83997de9c11096c6c54074f0e64bfaede0c Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 21 Mar 2016 09:28:20 +0900 Subject: [PATCH 11/16] add tdm_helper_get_fd & tdm_helper_set_fd Change-Id: I07027116cf37fd312eda56c49b271b2f36575c8f --- include/tdm_helper.h | 27 ++++++++++++++++++++++++++ src/tdm.c | 3 +++ src/tdm_helper.c | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 83 insertions(+) diff --git a/include/tdm_helper.h b/include/tdm_helper.h index 86b6620..c329669 100644 --- a/include/tdm_helper.h +++ b/include/tdm_helper.h @@ -68,6 +68,33 @@ extern "C" { void tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file); +/** + * @brief Get a fd from the given enviroment variable. + * @details + * This function will dup the fd of the given enviroment variable. The Caller + * @b SHOULD close the fd. + * \n + * In DRM system, a drm-master-fd @b SHOULD be shared between TDM backend and + * TBM backend in display server side by using "TDM_DRM_MASTER_FD" + * and "TBM_DRM_MASTER_FD". + * @param[in] env The given enviroment variable + * @return fd if success. Otherwise, -1. + * @see #tdm_helper_set_fd() + */ +int tdm_helper_get_fd(const char *env); + +/** + * @brief Set the given fd to the give enviroment variable. + * @details + * In DRM system, a drm-master-fd @b SHOULD be shared between TDM backend and + * TBM backend in display server side by using "TDM_DRM_MASTER_FD" + * and "TBM_DRM_MASTER_FD". + * @param[in] env The given enviroment variable + * @param[in] fd The given fd + * @see #tdm_helper_get_fd() + */ +void tdm_helper_set_fd(const char *env, int fd); + #ifdef __cplusplus } #endif diff --git a/src/tdm.c b/src/tdm.c index a7451f1..1a02ef1 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -40,6 +40,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tdm.h" #include "tdm_backend.h" #include "tdm_private.h" +#include "tdm_helper.h" static tdm_private_layer * _tdm_display_find_private_layer(tdm_private_output *private_output, @@ -784,6 +785,8 @@ tdm_display_deinit(tdm_display *dpy) _tdm_display_destroy_private_display(private_display); _tdm_display_unload_module(private_display); + tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1); + pthread_mutex_unlock(&private_display->lock); pthread_mutex_destroy(&private_display->lock); diff --git a/src/tdm_helper.c b/src/tdm_helper.c index 7c47b6e..311ea6e 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -173,3 +173,56 @@ tdm_helper_dump_buffer(tbm_surface_h buffer, const char *file) TDM_INFO("dump %s", file); } + +EXTERN int +tdm_helper_get_fd(const char *env) +{ + const char *value; + int fd, newfd, flags, ret; + + value = (const char*)getenv(env); + if (!value) + return -1; + + ret = sscanf(value, "%d", &fd); + if (ret < 0) { + TDM_ERR("sscanf failed: %m"); + return -1; + } + + flags = fcntl(fd, F_GETFD); + if (flags == -1) { + TDM_ERR("fcntl failed: %m"); + return -1; + } + + newfd = dup(fd); + if (newfd < 0) { + TDM_ERR("dup failed: %m"); + return -1; + } + + TDM_INFO("%s: fd(%d) newfd(%d)", env, fd, newfd); + + fcntl(newfd, F_SETFD, flags | FD_CLOEXEC); + + return newfd; +} + +EXTERN void +tdm_helper_set_fd(const char *env, int fd) +{ + char buf[32]; + int ret; + + snprintf(buf, sizeof(buf), "%d", fd); + + ret = setenv(env, (const char*)buf, 1); + if (ret) { + TDM_ERR("setenv failed: %m"); + return; + } + + if (fd >= 0) + TDM_INFO("%s: fd(%d)", env, fd); +} -- 2.7.4 From 3ea4356f111bd765f13f57f8581d9c1648a8b2b7 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 23 Mar 2016 11:13:44 +0900 Subject: [PATCH 12/16] use macro to debug mutex lock Change-Id: I7dd7d6d4674444068009c8d2288b4ff5a1daa828 --- include/tdm_log.h | 1 - src/tdm.c | 27 +++-- src/tdm_backend.c | 20 ++-- src/tdm_capture.c | 38 +++---- src/tdm_display.c | 302 +++++++++++++++++++++++++++--------------------------- src/tdm_pp.c | 46 ++++----- src/tdm_private.h | 8 ++ 7 files changed, 227 insertions(+), 215 deletions(-) diff --git a/include/tdm_log.h b/include/tdm_log.h index 451bbf8..1952e2a 100644 --- a/include/tdm_log.h +++ b/include/tdm_log.h @@ -52,7 +52,6 @@ extern "C" { * @endcode */ extern int tdm_debug; -extern int tdm_debug_buffer; //#define TDM_CONFIG_DLOG #ifdef TDM_CONFIG_DLOG diff --git a/src/tdm.c b/src/tdm.c index 1a02ef1..58c781a 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -461,11 +461,11 @@ tdm_display_update(tdm_display *dpy) TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); private_display = dpy; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); ret = _tdm_display_update_internal(private_display, 1); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -475,6 +475,7 @@ tdm_display_update(tdm_display *dpy) int tdm_debug; int tdm_debug_buffer; +int tdm_debug_mutex; static tdm_private_display *g_private_display; static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; @@ -697,11 +698,11 @@ tdm_display_init(tdm_error *error) const char *debug; tdm_error ret; - pthread_mutex_lock(&gLock); + _pthread_mutex_lock(&gLock); if (g_private_display) { g_private_display->init_count++; - pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&gLock); if (error) *error = TDM_ERROR_NONE; return g_private_display; @@ -715,6 +716,10 @@ tdm_display_init(tdm_error *error) if (debug && (strstr(debug, "1"))) tdm_debug_buffer = 1; + debug = getenv("TDM_DEBUG_MUTEX"); + if (debug && (strstr(debug, "1"))) + tdm_debug_mutex = 1; + private_display = calloc(1, sizeof(tdm_private_display)); if (!private_display) { ret = TDM_ERROR_OUT_OF_MEMORY; @@ -745,7 +750,7 @@ tdm_display_init(tdm_error *error) if (error) *error = TDM_ERROR_NONE; - pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&gLock); return (tdm_display *)private_display; @@ -760,7 +765,7 @@ failed_alloc: tdm_debug_buffer = 0; if (error) *error = ret; - pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&gLock); return NULL; } @@ -772,22 +777,22 @@ tdm_display_deinit(tdm_display *dpy) if (!private_display) return; - pthread_mutex_lock(&gLock); + _pthread_mutex_lock(&gLock); private_display->init_count--; if (private_display->init_count > 0) { - pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&gLock); return; } - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); _tdm_display_destroy_private_display(private_display); _tdm_display_unload_module(private_display); tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); pthread_mutex_destroy(&private_display->lock); free(private_display); @@ -795,6 +800,6 @@ tdm_display_deinit(tdm_display *dpy) tdm_debug = 0; tdm_debug_buffer = 0; - pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&gLock); } diff --git a/src/tdm_backend.c b/src/tdm_backend.c index 8f34672..9dfa2d1 100644 --- a/src/tdm_backend.c +++ b/src/tdm_backend.c @@ -78,9 +78,9 @@ tdm_backend_register_func_display(tdm_display *dpy, if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_display->func_display = *func_display; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -99,9 +99,9 @@ tdm_backend_register_func_output(tdm_display *dpy, tdm_func_output *func_output) if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_display->func_output = *func_output; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -120,9 +120,9 @@ tdm_backend_register_func_layer(tdm_display *dpy, tdm_func_layer *func_layer) if (_check_abi_version(module, 1, 1) < 0) return TDM_ERROR_BAD_MODULE; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_display->func_layer = *func_layer; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -135,10 +135,10 @@ tdm_backend_register_func_pp(tdm_display *dpy, tdm_func_pp *func_pp) if (!func_pp) return TDM_ERROR_NONE; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_display->capabilities |= TDM_DISPLAY_CAPABILITY_PP; private_display->func_pp = *func_pp; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -152,10 +152,10 @@ tdm_backend_register_func_capture(tdm_display *dpy, if (!func_capture) return TDM_ERROR_NONE; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_display->capabilities |= TDM_DISPLAY_CAPABILITY_CAPTURE; private_display->func_capture = *func_capture; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } diff --git a/src/tdm_capture.c b/src/tdm_capture.c index a68739d..014d082 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -97,16 +97,16 @@ _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, ret = pthread_mutex_trylock(&private_display->lock); if (ret == 0) - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); else if (ret == EBUSY) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); lock_after_cb_done = 1; } tdm_buffer_unref_backend(buffer); if (lock_after_cb_done) - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } INTERN tdm_private_capture * @@ -240,9 +240,9 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->pending_buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -252,9 +252,9 @@ tdm_capture_destroy_internal(tdm_private_capture *private_capture) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_capture->buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -272,9 +272,9 @@ tdm_capture_destroy(tdm_capture *capture) private_display = private_capture->private_display; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); tdm_capture_destroy_internal(private_capture); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); } EXTERN tdm_error @@ -284,17 +284,17 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info) TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_capture->capture_set_info) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_capture->capture_set_info(private_capture->capture_backend, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -306,16 +306,16 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_capture->capture_attach) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = _tdm_capture_check_if_exist(private_capture, buffer); if (ret != TDM_ERROR_NONE) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -334,7 +334,7 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) } } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -346,10 +346,10 @@ tdm_capture_commit(tdm_capture *capture) CAPTURE_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_capture->capture_commit) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -367,7 +367,7 @@ tdm_capture_commit(tdm_capture *capture) LIST_DEL(&b->link); } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } diff --git a/src/tdm_display.c b/src/tdm_display.c index cbcf675..9e3106f 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -109,11 +109,11 @@ tdm_display_get_capabilities(tdm_display *dpy, TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *capabilities = private_display->capabilities; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -126,17 +126,17 @@ tdm_display_get_pp_capabilities(tdm_display *dpy, TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { TDM_ERR("no pp capability"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NO_CAPABILITY; } *capabilities = private_display->caps_pp.capabilities; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -150,18 +150,18 @@ tdm_display_get_pp_available_formats(tdm_display *dpy, 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); + _pthread_mutex_lock(&private_display->lock); if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { TDM_ERR("no pp capability"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NO_CAPABILITY; } *formats = (const tbm_format *)private_display->caps_pp.formats; *count = private_display->caps_pp.format_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -172,11 +172,11 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, { DISPLAY_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) { TDM_ERR("no pp capability"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NO_CAPABILITY; } @@ -191,7 +191,7 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, if (preferred_align) *preferred_align = private_display->caps_pp.preferred_align; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -204,17 +204,17 @@ tdm_display_get_capture_capabilities(tdm_display *dpy, TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { TDM_ERR("no capture capability"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NO_CAPABILITY; } *capabilities = private_display->caps_capture.capabilities; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -228,18 +228,18 @@ tdm_display_get_catpure_available_formats(tdm_display *dpy, 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); + _pthread_mutex_lock(&private_display->lock); if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) { TDM_ERR("no capture capability"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NO_CAPABILITY; } *formats = (const tbm_format *)private_display->caps_capture.formats; *count = private_display->caps_capture.format_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -253,18 +253,18 @@ tdm_display_get_output_count(tdm_display *dpy, int *count) TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *count = 0; LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) (*count)++; if (*count == 0) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -278,7 +278,7 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) DISPLAY_FUNC_ENTRY_ERROR(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (error) *error = TDM_ERROR_NONE; @@ -286,13 +286,13 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) i = 0; LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) { if (i == index) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return private_output; } i++; } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return NULL; } @@ -305,7 +305,7 @@ tdm_display_get_fd(tdm_display *dpy, int *fd) TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_display = &private_display->func_display; @@ -316,7 +316,7 @@ tdm_display_get_fd(tdm_display *dpy, int *fd) ret = func_display->display_get_fd(private_display->bdata, fd); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -327,7 +327,7 @@ tdm_display_handle_events(tdm_display *dpy) tdm_func_display *func_display; DISPLAY_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_display = &private_display->func_display; @@ -338,7 +338,7 @@ tdm_display_handle_events(tdm_display *dpy) ret = func_display->display_handle_events(private_display->bdata); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -350,11 +350,11 @@ tdm_display_create_pp(tdm_display *dpy, tdm_error *error) DISPLAY_FUNC_ENTRY_ERROR(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); pp = (tdm_pp *)tdm_pp_create_internal(private_display, error); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return pp; } @@ -365,7 +365,7 @@ tdm_output_get_model_info(tdm_output *output, const char **maker, { OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (maker) *maker = private_output->caps.maker; @@ -374,7 +374,7 @@ tdm_output_get_model_info(tdm_output *output, const char **maker, if (name) *name = private_output->caps.name; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -386,11 +386,11 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status) TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *status = private_output->caps.status; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -402,11 +402,11 @@ tdm_output_get_output_type(tdm_output *output, tdm_output_type *type) TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *type = private_output->caps.type; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -420,17 +420,17 @@ tdm_output_get_layer_count(tdm_output *output, int *count) TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *count = 0; LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) (*count)++; if (*count == 0) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -444,20 +444,20 @@ tdm_output_get_layer(tdm_output *output, int index, tdm_error *error) OUTPUT_FUNC_ENTRY_ERROR(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (error) *error = TDM_ERROR_NONE; LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) { if (i == index) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return private_layer; } i++; } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return NULL; } @@ -471,12 +471,12 @@ tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, 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); + _pthread_mutex_lock(&private_display->lock); *props = (const tdm_prop *)private_output->caps.props; *count = private_output->caps.prop_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -490,12 +490,12 @@ tdm_output_get_available_modes(tdm_output *output, TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *modes = (const tdm_output_mode *)private_output->caps.modes; *count = private_output->caps.mode_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -506,7 +506,7 @@ tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h, { OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (min_w) *min_w = private_output->caps.min_w; @@ -519,7 +519,7 @@ tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h, if (preferred_align) *preferred_align = private_output->caps.preferred_align; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -530,14 +530,14 @@ tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, { OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (mmWidth) *mmWidth = private_output->caps.mmWidth; if (mmHeight) *mmHeight = private_output->caps.mmHeight; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -548,11 +548,11 @@ tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel) OUTPUT_FUNC_ENTRY(); TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *subpixel = private_output->caps.subpixel; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -563,11 +563,11 @@ tdm_output_get_pipe(tdm_output *output, unsigned int *pipe) OUTPUT_FUNC_ENTRY(); TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *pipe = private_output->pipe; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -579,19 +579,19 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) tdm_func_output *func_output; OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_set_property) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_set_property(private_output->output_backend, id, value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -604,19 +604,19 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_get_property) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_get_property(private_output->output_backend, id, value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -633,10 +633,10 @@ _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence, private_display = vblank_handler->private_output->private_display; if (vblank_handler->func) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); vblank_handler->func(vblank_handler->private_output, sequence, tv_sec, tv_usec, vblank_handler->user_data); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } LIST_DEL(&vblank_handler->link); @@ -662,15 +662,15 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, continue; if (private_layer->showing_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->showing_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (private_layer->buffer_queue) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->showing_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -684,10 +684,10 @@ _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence, } if (commit_handler->func) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); commit_handler->func(private_output, sequence, tv_sec, tv_usec, commit_handler->user_data); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } LIST_DEL(&commit_handler->link); @@ -702,19 +702,19 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_private_vblank_handler *vblank_handler; OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_wait_vblank) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler)); if (!vblank_handler) { TDM_ERR("failed: alloc memory"); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_OUT_OF_MEMORY; } @@ -726,7 +726,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, ret = func_output->output_wait_vblank(private_output->output_backend, interval, sync, vblank_handler); if (ret != TDM_ERROR_NONE) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -736,7 +736,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, _tdm_output_cb_vblank); } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -785,11 +785,11 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, { OUTPUT_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); ret = _tdm_output_commit(output, sync, func, user_data); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -802,18 +802,18 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_set_mode) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_set_mode(private_output->output_backend, mode); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -826,18 +826,18 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode) TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_get_mode) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_get_mode(private_output->output_backend, mode); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -853,18 +853,18 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) else if (dpms_value > TDM_OUTPUT_DPMS_OFF) dpms_value = TDM_OUTPUT_DPMS_OFF; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_set_dpms) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_set_dpms(private_output->output_backend, dpms_value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -877,18 +877,18 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value) TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_output = &private_display->func_output; if (!func_output->output_get_dpms) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_output->output_get_dpms(private_output->output_backend, dpms_value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -900,12 +900,12 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error) OUTPUT_FUNC_ENTRY_ERROR(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); capture = (tdm_capture *)tdm_capture_create_output_internal(private_output, error); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return capture; } @@ -917,11 +917,11 @@ tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities) TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *capabilities = private_layer->caps.capabilities; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -935,12 +935,12 @@ tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, 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); + _pthread_mutex_lock(&private_display->lock); *formats = (const tbm_format *)private_layer->caps.formats; *count = private_layer->caps.format_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -954,12 +954,12 @@ tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, 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); + _pthread_mutex_lock(&private_display->lock); *props = (const tdm_prop *)private_layer->caps.props; *count = private_layer->caps.prop_count; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -971,11 +971,11 @@ tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos) TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *zpos = private_layer->caps.zpos; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -986,18 +986,18 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value) tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (!func_layer->layer_set_property) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_set_property(private_layer->layer_backend, id, value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1010,18 +1010,18 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value) TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (!func_layer->layer_get_property) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_get_property(private_layer->layer_backend, id, value); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1034,14 +1034,14 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info) TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; private_layer->usable = 0; if (!func_layer->layer_set_info) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -1057,7 +1057,7 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info) ret = func_layer->layer_set_info(private_layer->layer_backend, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1070,18 +1070,18 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info) TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (!func_layer->layer_get_info) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_get_info(private_layer->layer_backend, info); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1095,14 +1095,14 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; private_layer->usable = 0; if (!func_layer->layer_set_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -1114,9 +1114,9 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) * successfully, need to move to waiting_buffer. */ if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer); @@ -1125,7 +1125,7 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) private_layer, private_layer->waiting_buffer); } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1136,14 +1136,14 @@ tdm_layer_unset_buffer(tdm_layer *layer) tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_layer->waiting_buffer = NULL; if (tdm_debug_buffer) @@ -1152,9 +1152,9 @@ tdm_layer_unset_buffer(tdm_layer *layer) } if (private_layer->showing_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->showing_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_layer->showing_buffer = NULL; if (tdm_debug_buffer) @@ -1165,14 +1165,14 @@ tdm_layer_unset_buffer(tdm_layer *layer) private_layer->usable = 1; if (!func_layer->layer_unset_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_unset_buffer(private_layer->layer_backend); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1186,11 +1186,11 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) tbm_surface_h surface = NULL; LAYER_FUNC_ENTRY_VOID_RETURN(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (!func_layer->layer_set_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return; } @@ -1199,7 +1199,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) surface == NULL) { TDM_ERR("layer(%p) tbm_surface_queue_acquire() failed surface:%p", private_layer, surface); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return; } @@ -1208,11 +1208,11 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) if (ret == TDM_ERROR_NONE) { if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } private_layer->waiting_buffer = tdm_buffer_ref_backend(surface); @@ -1226,7 +1226,7 @@ _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data) TDM_ERR("layer(%p) _tdm_output_commit() is fail", private_layer); } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); } static void @@ -1237,19 +1237,19 @@ _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data) LAYER_FUNC_ENTRY_VOID_RETURN(); TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } private_layer->buffer_queue = NULL; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); } EXTERN tdm_error @@ -1260,29 +1260,29 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; private_layer->usable = 0; if (!func_layer->layer_set_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } if (buffer_queue == private_layer->buffer_queue) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer); private_layer->waiting_buffer = NULL; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (tdm_debug_buffer) TDM_INFO("layer(%p) waiting_buffer(%p)", @@ -1296,7 +1296,7 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) tbm_surface_queue_add_destroy_cb(private_layer->buffer_queue, _tbm_layer_queue_destroy_cb, layer); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1307,17 +1307,17 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer) tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (private_layer->waiting_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->waiting_buffer); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer); private_layer->waiting_buffer = NULL; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (tdm_debug_buffer) TDM_INFO("layer(%p) waiting_buffer(%p)", @@ -1325,11 +1325,11 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer) } if (private_layer->showing_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(private_layer->showing_buffer); tbm_surface_queue_release(private_layer->buffer_queue, private_layer->showing_buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); private_layer->showing_buffer = NULL; if (tdm_debug_buffer) @@ -1343,13 +1343,13 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer) private_layer->usable = 1; if (!func_layer->layer_unset_buffer) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_unset_buffer(private_layer->layer_backend); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1361,11 +1361,11 @@ tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable) TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); *usable = private_layer->usable; - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1376,24 +1376,24 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos) tdm_func_layer *func_layer; LAYER_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); func_layer = &private_display->func_layer; if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)) { TDM_ERR("layer(%p) is not video layer", private_layer); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_INVALID_PARAMETER; } if (!func_layer->layer_set_video_pos) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -1405,12 +1405,12 @@ tdm_layer_create_capture(tdm_layer *layer, tdm_error *error) LAYER_FUNC_ENTRY_ERROR(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); capture = (tdm_capture *)tdm_capture_create_layer_internal(private_layer, error); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return capture; } diff --git a/src/tdm_pp.c b/src/tdm_pp.c index cd88f49..6e59c51 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -118,9 +118,9 @@ _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, ret = pthread_mutex_trylock(&private_display->lock); if (ret == 0) - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); else if (ret == EBUSY) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); lock_after_cb_done = 1; } @@ -128,7 +128,7 @@ _tdm_pp_cb_done(tdm_pp *pp_backend, tbm_surface_h src, tbm_surface_h dst, tdm_buffer_unref_backend(dst); if (lock_after_cb_done) - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } INTERN tdm_private_pp * @@ -213,9 +213,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_pending_buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -225,9 +225,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_pending_buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -237,9 +237,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->src_buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -249,9 +249,9 @@ tdm_pp_destroy_internal(tdm_private_pp *private_pp) LIST_FOR_EACH_ENTRY_SAFE(b, bb, &private_pp->dst_buffer_list, link) { LIST_DEL(&b->link); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); tdm_buffer_unref_backend(b->buffer); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); } } @@ -269,9 +269,9 @@ tdm_pp_destroy(tdm_pp *pp) private_display = private_pp->private_display; - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); tdm_pp_destroy_internal(private_pp); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); } EXTERN tdm_error @@ -281,10 +281,10 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_pp->pp_set_info) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -302,7 +302,7 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) ret = func_pp->pp_set_info(private_pp->pp_backend, info); TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -315,16 +315,16 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) TDM_RETURN_VAL_IF_FAIL(src != NULL, TDM_ERROR_INVALID_PARAMETER); TDM_RETURN_VAL_IF_FAIL(dst != NULL, TDM_ERROR_INVALID_PARAMETER); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_pp->pp_attach) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } ret = _tdm_pp_check_if_exist(private_pp, src, dst); if (ret != TDM_ERROR_NONE) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -347,7 +347,7 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) } } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } @@ -359,10 +359,10 @@ tdm_pp_commit(tdm_pp *pp) PP_FUNC_ENTRY(); - pthread_mutex_lock(&private_display->lock); + _pthread_mutex_lock(&private_display->lock); if (!func_pp->pp_commit) { - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return TDM_ERROR_NONE; } @@ -388,7 +388,7 @@ tdm_pp_commit(tdm_pp *pp) LIST_DEL(&b->link); } - pthread_mutex_unlock(&private_display->lock); + _pthread_mutex_unlock(&private_display->lock); return ret; } diff --git a/src/tdm_private.h b/src/tdm_private.h index c1a34d0..15a2448 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -65,6 +65,9 @@ extern "C" { * @brief The private header file for a frontend library */ +extern int tdm_debug_buffer; +extern int tdm_debug_mutex; + #undef EXTERN #undef DEPRECATED #undef INTERN @@ -308,6 +311,11 @@ tdm_buffer_list_get_first_entry(struct list_head *list); void tdm_buffer_list_dump(struct list_head *list); +#define _pthread_mutex_lock(l) \ + do {if (tdm_debug_mutex) TDM_INFO("mutex lock"); pthread_mutex_lock(l);} while (0) +#define _pthread_mutex_unlock(l) \ + do {if (tdm_debug_mutex) TDM_INFO("mutex unlock"); pthread_mutex_unlock(l);} while (0) + #ifdef __cplusplus } #endif -- 2.7.4 From 44c855ea9c8e53404ca282c960cc94705b88931a Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 23 Mar 2016 11:22:09 +0900 Subject: [PATCH 13/16] use a tab instead of 8 spaces Change-Id: I43e97a5d0ab49ba06f281a4c077c070e9534d744 --- include/tdm_types.h | 140 ++++++++++++++++++++++++++-------------------------- 1 file changed, 70 insertions(+), 70 deletions(-) diff --git a/include/tdm_types.h b/include/tdm_types.h index af69324..e31a96b 100755 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -80,23 +80,23 @@ typedef enum * @brief The transform enumeration(rotate, flip) */ typedef enum { - TDM_TRANSFORM_NORMAL = 0, /**< no transform */ - TDM_TRANSFORM_90 = 1, /**< rotate 90 */ - TDM_TRANSFORM_180 = 2, /**< rotate 180 */ - TDM_TRANSFORM_270 = 3, /**< rotate 270 */ - TDM_TRANSFORM_FLIPPED = 4, /**< no rotate and horizontal flip */ - TDM_TRANSFORM_FLIPPED_90 = 5, /**< rotate 90 and horizontal flip */ - TDM_TRANSFORM_FLIPPED_180 = 6, /**< rotate 180 and horizontal flip */ - TDM_TRANSFORM_FLIPPED_270 = 7, /**< rotate 270 and horizontal flip */ + TDM_TRANSFORM_NORMAL = 0, /**< no transform */ + TDM_TRANSFORM_90 = 1, /**< rotate 90 */ + TDM_TRANSFORM_180 = 2, /**< rotate 180 */ + TDM_TRANSFORM_270 = 3, /**< rotate 270 */ + TDM_TRANSFORM_FLIPPED = 4, /**< no rotate and horizontal flip */ + TDM_TRANSFORM_FLIPPED_90 = 5, /**< rotate 90 and horizontal flip */ + TDM_TRANSFORM_FLIPPED_180 = 6, /**< rotate 180 and horizontal flip */ + TDM_TRANSFORM_FLIPPED_270 = 7, /**< rotate 270 and horizontal flip */ } tdm_transform; /** * @brief The output connection status enumeration */ typedef enum { - TDM_OUTPUT_CONN_STATUS_DISCONNECTED, /**< output disconnected */ - TDM_OUTPUT_CONN_STATUS_CONNECTED, /**< output connected */ - TDM_OUTPUT_CONN_STATUS_MODE_SETTED, /**< output connected and setted a mode */ + TDM_OUTPUT_CONN_STATUS_DISCONNECTED, /**< output disconnected */ + TDM_OUTPUT_CONN_STATUS_CONNECTED, /**< output connected */ + TDM_OUTPUT_CONN_STATUS_MODE_SETTED, /**< output connected and setted a mode */ } tdm_output_conn_status; /** @@ -104,23 +104,23 @@ typedef enum { * @details bit compatible with the libdrm definitions. */ typedef enum { - TDM_OUTPUT_TYPE_Unknown, /**< unknown */ - TDM_OUTPUT_TYPE_VGA, /**< VGA connection */ - TDM_OUTPUT_TYPE_DVII, /**< DVII connection */ - TDM_OUTPUT_TYPE_DVID, /**< DVID connection */ - TDM_OUTPUT_TYPE_DVIA, /**< DVIA connection */ - TDM_OUTPUT_TYPE_Composite, /**< Composite connection */ - TDM_OUTPUT_TYPE_SVIDEO, /**< SVIDEO connection */ - TDM_OUTPUT_TYPE_LVDS, /**< LVDS connection */ - TDM_OUTPUT_TYPE_Component, /**< Component connection */ - TDM_OUTPUT_TYPE_9PinDIN, /**< 9PinDIN connection */ - TDM_OUTPUT_TYPE_DisplayPort, /**< DisplayPort connection */ - TDM_OUTPUT_TYPE_HDMIA, /**< HDMIA connection */ - TDM_OUTPUT_TYPE_HDMIB, /**< HDMIB connection */ - TDM_OUTPUT_TYPE_TV, /**< TV connection */ - TDM_OUTPUT_TYPE_eDP, /**< eDP connection */ - TDM_OUTPUT_TYPE_VIRTUAL, /**< Virtual connection for WiFi Display */ - TDM_OUTPUT_TYPE_DSI, /**< DSI connection */ + TDM_OUTPUT_TYPE_Unknown, /**< unknown */ + TDM_OUTPUT_TYPE_VGA, /**< VGA connection */ + TDM_OUTPUT_TYPE_DVII, /**< DVII connection */ + TDM_OUTPUT_TYPE_DVID, /**< DVID connection */ + TDM_OUTPUT_TYPE_DVIA, /**< DVIA connection */ + TDM_OUTPUT_TYPE_Composite, /**< Composite connection */ + TDM_OUTPUT_TYPE_SVIDEO, /**< SVIDEO connection */ + TDM_OUTPUT_TYPE_LVDS, /**< LVDS connection */ + TDM_OUTPUT_TYPE_Component, /**< Component connection */ + TDM_OUTPUT_TYPE_9PinDIN, /**< 9PinDIN connection */ + TDM_OUTPUT_TYPE_DisplayPort, /**< DisplayPort connection */ + TDM_OUTPUT_TYPE_HDMIA, /**< HDMIA connection */ + TDM_OUTPUT_TYPE_HDMIB, /**< HDMIB connection */ + TDM_OUTPUT_TYPE_TV, /**< TV connection */ + TDM_OUTPUT_TYPE_eDP, /**< eDP connection */ + TDM_OUTPUT_TYPE_VIRTUAL, /**< Virtual connection for WiFi Display */ + TDM_OUTPUT_TYPE_DSI, /**< DSI connection */ } tdm_output_type; /** @@ -128,10 +128,10 @@ typedef enum { * @details bit compatible with the libdrm definitions. */ typedef enum { - TDM_OUTPUT_DPMS_ON, /**< On */ - TDM_OUTPUT_DPMS_STANDBY, /**< StandBy */ - TDM_OUTPUT_DPMS_SUSPEND, /**< Suspend */ - TDM_OUTPUT_DPMS_OFF, /**< Off */ + TDM_OUTPUT_DPMS_ON, /**< On */ + TDM_OUTPUT_DPMS_STANDBY, /**< StandBy */ + TDM_OUTPUT_DPMS_SUSPEND, /**< Suspend */ + TDM_OUTPUT_DPMS_OFF, /**< Off */ } tdm_output_dpms; /** @@ -158,35 +158,35 @@ typedef enum { * buffer to a VIDEO layer without converting. */ typedef enum { - TDM_LAYER_CAPABILITY_CURSOR = (1 << 0), /**< cursor */ - TDM_LAYER_CAPABILITY_PRIMARY = (1 << 1), /**< primary */ - TDM_LAYER_CAPABILITY_OVERLAY = (1 << 2), /**< overlay */ - TDM_LAYER_CAPABILITY_GRAPHIC = (1 << 4), /**< graphic */ - TDM_LAYER_CAPABILITY_VIDEO = (1 << 5), /**< video */ - TDM_LAYER_CAPABILITY_SCALE = (1 << 8), /**< if a layer has scale capability */ - TDM_LAYER_CAPABILITY_TRANSFORM = (1 << 9), /**< if a layer has transform capability */ - TDM_LAYER_CAPABILITY_SCANOUT = (1 << 10), /**< if a layer allows a scanout buffer only */ - TDM_LAYER_CAPABILITY_RESEVED_MEMORY = (1 << 11), /**< if a layer allows a reserved buffer only */ + TDM_LAYER_CAPABILITY_CURSOR = (1 << 0), /**< cursor */ + TDM_LAYER_CAPABILITY_PRIMARY = (1 << 1), /**< primary */ + TDM_LAYER_CAPABILITY_OVERLAY = (1 << 2), /**< overlay */ + TDM_LAYER_CAPABILITY_GRAPHIC = (1 << 4), /**< graphic */ + TDM_LAYER_CAPABILITY_VIDEO = (1 << 5), /**< video */ + TDM_LAYER_CAPABILITY_SCALE = (1 << 8), /**< if a layer has scale capability */ + TDM_LAYER_CAPABILITY_TRANSFORM = (1 << 9), /**< if a layer has transform capability */ + TDM_LAYER_CAPABILITY_SCANOUT = (1 << 10), /**< if a layer allows a scanout buffer only */ + TDM_LAYER_CAPABILITY_RESEVED_MEMORY = (1 << 11), /**< if a layer allows a reserved buffer only */ } tdm_layer_capability; /** * @brief The pp capability enumeration */ typedef enum { - TDM_PP_CAPABILITY_SYNC = (1 << 0), /**< The pp device supports synchronous operation */ - TDM_PP_CAPABILITY_ASYNC = (1 << 1), /**< The pp device supports asynchronous operation */ - TDM_PP_CAPABILITY_SCALE = (1 << 4), /**< The pp device supports scale operation */ - TDM_PP_CAPABILITY_TRANSFORM = (1 << 5), /**< The pp device supports transform operation */ + TDM_PP_CAPABILITY_SYNC = (1 << 0), /**< The pp device supports synchronous operation */ + TDM_PP_CAPABILITY_ASYNC = (1 << 1), /**< The pp device supports asynchronous operation */ + TDM_PP_CAPABILITY_SCALE = (1 << 4), /**< The pp device supports scale operation */ + TDM_PP_CAPABILITY_TRANSFORM = (1 << 5), /**< The pp device supports transform operation */ } tdm_pp_capability; /** * @brief The capture capability enumeration */ typedef enum { - TDM_CAPTURE_CAPABILITY_OUTPUT = (1 << 0), /**< The capture device supports to dump a output */ - TDM_CAPTURE_CAPABILITY_LAYER = (1 << 1), /**< The capture device supports to dump a layer */ - TDM_CAPTURE_CAPABILITY_SCALE = (1 << 4), /**< The capture device supports scale operation */ - TDM_CAPTURE_CAPABILITY_TRANSFORM = (1 << 5), /**< The capture device supports transform operation */ + TDM_CAPTURE_CAPABILITY_OUTPUT = (1 << 0), /**< The capture device supports to dump a output */ + TDM_CAPTURE_CAPABILITY_LAYER = (1 << 1), /**< The capture device supports to dump a layer */ + TDM_CAPTURE_CAPABILITY_SCALE = (1 << 4), /**< The capture device supports scale operation */ + TDM_CAPTURE_CAPABILITY_TRANSFORM = (1 << 5), /**< The capture device supports transform operation */ } tdm_capture_capability; /** @@ -194,13 +194,13 @@ typedef enum { * @details bit compatible with the libdrm definitions. */ typedef enum { - TDM_OUTPUT_MODE_TYPE_BUILTIN = (1 << 0), - TDM_OUTPUT_MODE_TYPE_CLOCK_C = ((1 << 1) | TDM_OUTPUT_MODE_TYPE_BUILTIN), - TDM_OUTPUT_MODE_TYPE_CRTC_C = ((1 << 2) | TDM_OUTPUT_MODE_TYPE_BUILTIN), - TDM_OUTPUT_MODE_TYPE_PREFERRED = (1 << 3), - TDM_OUTPUT_MODE_TYPE_DEFAULT = (1 << 4), - TDM_OUTPUT_MODE_TYPE_USERDEF = (1 << 5), - TDM_OUTPUT_MODE_TYPE_DRIVER = (1 << 6), + TDM_OUTPUT_MODE_TYPE_BUILTIN = (1 << 0), + TDM_OUTPUT_MODE_TYPE_CLOCK_C = ((1 << 1) | TDM_OUTPUT_MODE_TYPE_BUILTIN), + TDM_OUTPUT_MODE_TYPE_CRTC_C = ((1 << 2) | TDM_OUTPUT_MODE_TYPE_BUILTIN), + TDM_OUTPUT_MODE_TYPE_PREFERRED = (1 << 3), + TDM_OUTPUT_MODE_TYPE_DEFAULT = (1 << 4), + TDM_OUTPUT_MODE_TYPE_USERDEF = (1 << 5), + TDM_OUTPUT_MODE_TYPE_DRIVER = (1 << 6), } tdm_output_mode_type; /** @@ -208,20 +208,20 @@ typedef enum { * @details bit compatible with the libdrm definitions. */ typedef enum { - TDM_OUTPUT_MODE_FLAG_PHSYNC = (1 << 0), - TDM_OUTPUT_MODE_FLAG_NHSYNC = (1 << 1), - TDM_OUTPUT_MODE_FLAG_PVSYNC = (1 << 2), - TDM_OUTPUT_MODE_FLAG_NVSYNC = (1 << 3), - TDM_OUTPUT_MODE_FLAG_INTERLACE = (1 << 4), - TDM_OUTPUT_MODE_FLAG_DBLSCAN = (1 << 5), - TDM_OUTPUT_MODE_FLAG_CSYNC = (1 << 6), - TDM_OUTPUT_MODE_FLAG_PCSYNC = (1 << 7), - TDM_OUTPUT_MODE_FLAG_NCSYNC = (1 << 8), - TDM_OUTPUT_MODE_FLAG_HSKEW = (1 << 9), /* hskew provided */ - TDM_OUTPUT_MODE_FLAG_BCAST = (1 << 10), - TDM_OUTPUT_MODE_FLAG_PIXMUX = (1 << 11), - TDM_OUTPUT_MODE_FLAG_DBLCLK = (1 << 12), - TDM_OUTPUT_MODE_FLAG_CLKDIV2 = (1 << 13), + TDM_OUTPUT_MODE_FLAG_PHSYNC = (1 << 0), + TDM_OUTPUT_MODE_FLAG_NHSYNC = (1 << 1), + TDM_OUTPUT_MODE_FLAG_PVSYNC = (1 << 2), + TDM_OUTPUT_MODE_FLAG_NVSYNC = (1 << 3), + TDM_OUTPUT_MODE_FLAG_INTERLACE = (1 << 4), + TDM_OUTPUT_MODE_FLAG_DBLSCAN = (1 << 5), + TDM_OUTPUT_MODE_FLAG_CSYNC = (1 << 6), + TDM_OUTPUT_MODE_FLAG_PCSYNC = (1 << 7), + TDM_OUTPUT_MODE_FLAG_NCSYNC = (1 << 8), + TDM_OUTPUT_MODE_FLAG_HSKEW = (1 << 9), /* hskew provided */ + TDM_OUTPUT_MODE_FLAG_BCAST = (1 << 10), + TDM_OUTPUT_MODE_FLAG_PIXMUX = (1 << 11), + TDM_OUTPUT_MODE_FLAG_DBLCLK = (1 << 12), + TDM_OUTPUT_MODE_FLAG_CLKDIV2 = (1 << 13), } tdm_output_mode_flag; /** -- 2.7.4 From c134222b29c47dcdca1ac701037ac4aa71294276 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 23 Mar 2016 11:51:06 +0900 Subject: [PATCH 14/16] return TDM_ERROR_NOT_IMPLEMENTED if backend doesn't implenment Change-Id: Ic4b297c8992aa9e6bc60d8530cb9ed72e2ccc694 --- src/tdm_capture.c | 9 ++++++--- src/tdm_display.c | 51 ++++++++++++++++++++++++++++++++++----------------- src/tdm_pp.c | 9 ++++++--- 3 files changed, 46 insertions(+), 23 deletions(-) diff --git a/src/tdm_capture.c b/src/tdm_capture.c index 014d082..1da64d8 100644 --- a/src/tdm_capture.c +++ b/src/tdm_capture.c @@ -288,7 +288,8 @@ tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info) if (!func_capture->capture_set_info) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_capture->capture_set_info(private_capture->capture_backend, info); @@ -310,7 +311,8 @@ tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer) if (!func_capture->capture_attach) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = _tdm_capture_check_if_exist(private_capture, buffer); @@ -350,7 +352,8 @@ tdm_capture_commit(tdm_capture *capture) if (!func_capture->capture_commit) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_capture->capture_commit(private_capture->capture_backend); diff --git a/src/tdm_display.c b/src/tdm_display.c index 9e3106f..8e3dbe3 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -585,7 +585,8 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value) if (!func_output->output_set_property) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_set_property(private_output->output_backend, id, @@ -610,7 +611,8 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value) if (!func_output->output_get_property) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_get_property(private_output->output_backend, id, @@ -708,7 +710,8 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync, if (!func_output->output_wait_vblank) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler)); @@ -752,7 +755,8 @@ _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, func_output = &private_display->func_output; if (!func_output->output_commit) { - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } commit_handler = calloc(1, sizeof(tdm_private_commit_handler)); @@ -808,7 +812,8 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode) if (!func_output->output_set_mode) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_set_mode(private_output->output_backend, mode); @@ -832,7 +837,8 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode) if (!func_output->output_get_mode) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_get_mode(private_output->output_backend, mode); @@ -859,7 +865,8 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value) if (!func_output->output_set_dpms) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_set_dpms(private_output->output_backend, dpms_value); @@ -883,7 +890,8 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value) if (!func_output->output_get_dpms) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_output->output_get_dpms(private_output->output_backend, dpms_value); @@ -992,7 +1000,8 @@ tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value) if (!func_layer->layer_set_property) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_set_property(private_layer->layer_backend, id, value); @@ -1016,7 +1025,8 @@ tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value) if (!func_layer->layer_get_property) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_get_property(private_layer->layer_backend, id, value); @@ -1042,7 +1052,8 @@ tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info) if (!func_layer->layer_set_info) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } TDM_INFO("layer(%p) info: src(%dx%d %d,%d %dx%d %c%c%c%c) dst(%d,%d %dx%d) trans(%d)", @@ -1076,7 +1087,8 @@ tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info) if (!func_layer->layer_get_info) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_get_info(private_layer->layer_backend, info); @@ -1103,7 +1115,8 @@ tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer) if (!func_layer->layer_set_buffer) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_set_buffer(private_layer->layer_backend, buffer); @@ -1166,7 +1179,8 @@ tdm_layer_unset_buffer(tdm_layer *layer) if (!func_layer->layer_unset_buffer) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_unset_buffer(private_layer->layer_backend); @@ -1268,7 +1282,8 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) if (!func_layer->layer_set_buffer) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } if (buffer_queue == private_layer->buffer_queue) { @@ -1344,7 +1359,8 @@ tdm_layer_unset_buffer_queue(tdm_layer *layer) if (!func_layer->layer_unset_buffer) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_unset_buffer(private_layer->layer_backend); @@ -1388,7 +1404,8 @@ tdm_layer_set_video_pos(tdm_layer *layer, int zpos) if (!func_layer->layer_set_video_pos) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_layer->layer_set_video_pos(private_layer->layer_backend, zpos); diff --git a/src/tdm_pp.c b/src/tdm_pp.c index 6e59c51..683e09f 100644 --- a/src/tdm_pp.c +++ b/src/tdm_pp.c @@ -285,7 +285,8 @@ tdm_pp_set_info(tdm_pp *pp, tdm_info_pp *info) if (!func_pp->pp_set_info) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } TDM_INFO("pp(%p) info: src(%dx%d %d,%d %dx%d %c%c%c%c) dst(%dx%d %d,%d %dx%d %c%c%c%c) trans(%d) sync(%d) flags(%x)", @@ -319,7 +320,8 @@ tdm_pp_attach(tdm_pp *pp, tbm_surface_h src, tbm_surface_h dst) if (!func_pp->pp_attach) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = _tdm_pp_check_if_exist(private_pp, src, dst); @@ -363,7 +365,8 @@ tdm_pp_commit(tdm_pp *pp) if (!func_pp->pp_commit) { _pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; + TDM_DBG("failed: not implemented!!"); + return TDM_ERROR_NOT_IMPLEMENTED; } ret = func_pp->pp_commit(private_pp->pp_backend); -- 2.7.4 From 2ddbac2de262ac05d9867d5c02b30201f7b01377 Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 30 Mar 2016 17:16:48 +0900 Subject: [PATCH 15/16] use wl_event_loop to support the event handling system Conflicts: src/tdm_private.h Change-Id: Ie7be4057582a58d6c9db54edd39521e7bc7c4ab3 --- configure.ac | 8 +- include/tdm_backend.h | 18 +++ include/tdm_types.h | 22 ++++ packaging/libtdm.spec | 1 + src/Makefile.am | 1 + src/tdm.c | 7 ++ src/tdm_display.c | 20 +-- src/tdm_event.c | 336 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/tdm_private.h | 17 +++ 9 files changed, 408 insertions(+), 22 deletions(-) create mode 100644 src/tdm_event.c diff --git a/configure.ac b/configure.ac index c4b1a40..358c2e4 100644 --- a/configure.ac +++ b/configure.ac @@ -23,17 +23,17 @@ LT_INIT([disable-static]) # Enable quiet compiles on automake 1.11. m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) +PKG_CHECK_MODULES(TDM, libtbm pthread-stubs libpng wayland-server) + PKG_CHECK_MODULES(TTRACE, [ttrace], [have_ttrace="yes"], [have_ttrace="no"]) if test "x$have_ttrace" = "xyes"; then - PKG_CHECK_MODULES(TDM, libtbm pthread-stubs libpng ttrace) + TDM_CFLAGS="$TDM_CFLAGS $TTRACE_CFLAGS" + TDM_LIBS="$TDM_LIBS $TTRACE_LIBS" AC_DEFINE(HAVE_TTRACE, 1, [ttrace available]) -else - PKG_CHECK_MODULES(TDM, libtbm pthread-stubs libpng) fi -PKG_CHECK_MODULES(TDM, libtbm pthread-stubs libpng) AC_SUBST(TDM_CFLAGS) AC_SUBST(TDM_LIBS) diff --git a/include/tdm_backend.h b/include/tdm_backend.h index f240d41..0fe68c8 100644 --- a/include/tdm_backend.h +++ b/include/tdm_backend.h @@ -917,6 +917,24 @@ tdm_buffer_remove_destroy_handler(tbm_surface_h buffer, tdm_buffer_destroy_handler func, void *user_data); +tdm_event_source* +tdm_event_add_fd_handler(tdm_display *dpy, int fd, tdm_event_mask mask, + tdm_event_fd_handler func, void *user_data, + tdm_error *error); + +tdm_error +tdm_event_source_fd_update(tdm_event_source *source, tdm_event_mask mask); + +tdm_event_source* +tdm_event_add_timer_handler(tdm_display *dpy, tdm_event_timer_handler func, + void *user_data, tdm_error *error); + +tdm_error +tdm_event_source_timer_update(tdm_event_source *source, int ms_delay); + +void +tdm_event_source_remove(tdm_event_source *source); + #ifdef __cplusplus } #endif diff --git a/include/tdm_types.h b/include/tdm_types.h index e31a96b..5236982 100755 --- a/include/tdm_types.h +++ b/include/tdm_types.h @@ -224,6 +224,14 @@ typedef enum { TDM_OUTPUT_MODE_FLAG_CLKDIV2 = (1 << 13), } tdm_output_mode_flag; +typedef enum +{ + TDM_EVENT_READABLE = (1 << 0), + TDM_EVENT_WRITABLE = (1 << 1), + TDM_EVENT_HANGUP = (1 << 2), + TDM_EVENT_ERROR = (1 << 3), +} tdm_event_mask; + /** * @brief The output mode structure */ @@ -355,6 +363,20 @@ typedef void (*tdm_output_commit_handler)(tdm_output *output, unsigned int seque unsigned int tv_sec, unsigned int tv_usec, void *user_data); +/** + * @brief The tdm event source + */ +typedef void tdm_event_source; + +/** + * @brief The fd source handler + */ +typedef tdm_error (*tdm_event_fd_handler)(int fd, tdm_event_mask mask, void *user_data); + +/** + * @brief The timer source handler + */ +typedef tdm_error (*tdm_event_timer_handler)(void *user_data); #ifdef __cplusplus } diff --git a/packaging/libtdm.spec b/packaging/libtdm.spec index b06652b..0673f9c 100644 --- a/packaging/libtdm.spec +++ b/packaging/libtdm.spec @@ -10,6 +10,7 @@ BuildRequires: pkgconfig(pthread-stubs) BuildRequires: pkgconfig(libtbm) BuildRequires: pkgconfig(libpng) BuildRequires: pkgconfig(ttrace) +BuildRequires: pkgconfig(wayland-server) %description Common user library of Tizen Display Manager : libtdm front-end library diff --git a/src/Makefile.am b/src/Makefile.am index f445f27..2f994ba 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -11,6 +11,7 @@ libtdm_la_LIBADD = $(TDM_LIBS) -ldl -lpthread libtdm_la_SOURCES = \ tdm_backend.c \ + tdm_event.c \ tdm_helper.c \ tdm_buffer.c \ tdm_display.c \ diff --git a/src/tdm.c b/src/tdm.c index 58c781a..0023e7e 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -733,6 +733,10 @@ tdm_display_init(tdm_error *error) goto failed_mutex_init; } + ret = tdm_event_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_load; + ret = _tdm_display_load_module(private_display); if (ret != TDM_ERROR_NONE) goto failed_load; @@ -743,6 +747,8 @@ tdm_display_init(tdm_error *error) if (ret != TDM_ERROR_NONE) goto failed_update; + tdm_event_create_main_source(private_display); + private_display->init_count = 1; g_private_display = private_display; @@ -789,6 +795,7 @@ tdm_display_deinit(tdm_display *dpy) _tdm_display_destroy_private_display(private_display); _tdm_display_unload_module(private_display); + tdm_event_deinit(private_display); tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1); diff --git a/src/tdm_display.c b/src/tdm_display.c index 8e3dbe3..f730f11 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -300,21 +300,13 @@ tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error) EXTERN tdm_error tdm_display_get_fd(tdm_display *dpy, int *fd) { - tdm_func_display *func_display; DISPLAY_FUNC_ENTRY(); TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER); _pthread_mutex_lock(&private_display->lock); - func_display = &private_display->func_display; - - if (!func_display->display_get_fd) { - pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; - } - - ret = func_display->display_get_fd(private_display->bdata, fd); + *fd = tdm_event_get_fd(private_display); _pthread_mutex_unlock(&private_display->lock); @@ -324,19 +316,11 @@ tdm_display_get_fd(tdm_display *dpy, int *fd) EXTERN tdm_error tdm_display_handle_events(tdm_display *dpy) { - tdm_func_display *func_display; DISPLAY_FUNC_ENTRY(); _pthread_mutex_lock(&private_display->lock); - func_display = &private_display->func_display; - - if (!func_display->display_handle_events) { - pthread_mutex_unlock(&private_display->lock); - return TDM_ERROR_NONE; - } - - ret = func_display->display_handle_events(private_display->bdata); + ret = tdm_event_dispatch(private_display); _pthread_mutex_unlock(&private_display->lock); diff --git a/src/tdm_event.c b/src/tdm_event.c new file mode 100644 index 0000000..4c5f3a3 --- /dev/null +++ b/src/tdm_event.c @@ -0,0 +1,336 @@ +/************************************************************************** + +libtdm + +Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. + +Contact: Eunchul Kim , + JinYoung Jeon , + Taeheon Kim , + YoungJun Cho , + SooChan Lim , + Boram Park + +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.h" +#include "tdm_private.h" +#include "tdm_list.h" + +typedef struct _tdm_event_source_base +{ + struct wl_event_source *wl_source; +} tdm_event_source_base; + +typedef struct _tdm_event_source_fd +{ + tdm_event_source_base base; + tdm_private_display *private_display; + tdm_event_fd_handler func; + void *user_data; +} tdm_event_source_fd; + +typedef struct _tdm_event_source_timer +{ + tdm_event_source_base base; + tdm_private_display *private_display; + tdm_event_timer_handler func; + void *user_data; +} tdm_event_source_timer; + +static tdm_error +_tdm_event_main_fd_handler(int fd, tdm_event_mask mask, void *user_data) +{ + tdm_private_display *private_display = (tdm_private_display*)user_data; + tdm_func_display *func_display; + + TDM_RETURN_VAL_IF_FAIL(private_display != NULL, TDM_ERROR_OPERATION_FAILED); + + func_display = &private_display->func_display; + if (!func_display->display_handle_events) + return TDM_ERROR_NONE; + + return func_display->display_handle_events(private_display->bdata); +} + +INTERN tdm_error +tdm_event_init(tdm_private_display *private_display) +{ + if (private_display->event_loop) + return TDM_ERROR_NONE; + + private_display->event_loop = wl_event_loop_create(); + if (!private_display->event_loop) { + TDM_ERR("creating a event loop failed"); + return TDM_ERROR_OUT_OF_MEMORY; + } + + TDM_INFO("event_loop fd(%d)", + wl_event_loop_get_fd(private_display->event_loop)); + + return TDM_ERROR_NONE; +} + +INTERN void +tdm_event_deinit(tdm_private_display *private_display) +{ + if (private_display->main_source) { + tdm_event_source_remove(private_display->main_source); + private_display->main_source = NULL; + } + + if (private_display->event_loop) { + wl_event_loop_destroy(private_display->event_loop); + private_display->event_loop = NULL; + } +} + +INTERN void +tdm_event_create_main_source(tdm_private_display *private_display) +{ + tdm_func_display *func_display; + tdm_error ret; + int fd = -1; + + func_display = &private_display->func_display; + if (!func_display->display_get_fd) { + TDM_INFO("TDM backend module won't offer a display fd"); + return; + } + + ret = func_display->display_get_fd(private_display->bdata, &fd); + if (fd < 0) { + TDM_WRN("TDM backend module returns fd(%d)", fd); + return; + } + + if (!func_display->display_handle_events) { + TDM_ERR("no display_handle_events function"); + return; + } + + private_display->main_source = + tdm_event_add_fd_handler(private_display, fd, TDM_EVENT_READABLE, + _tdm_event_main_fd_handler, private_display, + &ret); + if (!private_display->main_source) { + TDM_ERR("no main event source"); + return; + } + + TDM_INFO("main event source created"); +} + +INTERN int +tdm_event_get_fd(tdm_private_display *private_display) +{ + if (!private_display->event_loop) + return -1; + + return wl_event_loop_get_fd(private_display->event_loop); +} + +INTERN tdm_error +tdm_event_dispatch(tdm_private_display *private_display) +{ + if (!private_display->event_loop) + return TDM_ERROR_NONE; + + if (wl_event_loop_dispatch(private_display->event_loop, 0) < 0) { + TDM_ERR("dispatch failed"); + return TDM_ERROR_OPERATION_FAILED; + } + + return TDM_ERROR_NONE; +} + +static int +_tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data) +{ + tdm_event_source_fd *fd_source = (tdm_event_source_fd*)data; + tdm_event_mask mask = 0; + + TDM_RETURN_VAL_IF_FAIL(fd_source, 1); + TDM_RETURN_VAL_IF_FAIL(fd_source->func, 1); + + if (wl_mask & WL_EVENT_READABLE) + mask |= TDM_EVENT_READABLE; + if (wl_mask & WL_EVENT_WRITABLE) + mask |= TDM_EVENT_WRITABLE; + if (wl_mask & WL_EVENT_HANGUP) + mask |= TDM_EVENT_HANGUP; + if (wl_mask & WL_EVENT_ERROR) + mask |= TDM_EVENT_ERROR; + + fd_source->func(fd, mask, fd_source->user_data); + + return 1; +} + +EXTERN tdm_event_source* +tdm_event_add_fd_handler(tdm_display *dpy, int fd, tdm_event_mask mask, + tdm_event_fd_handler func, void *user_data, + tdm_error *error) +{ + tdm_private_display *private_display; + tdm_event_source_fd *fd_source; + uint32_t wl_mask = 0; + tdm_error ret; + + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd >= 0, TDM_ERROR_INVALID_PARAMETER, NULL); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL); + + private_display = (tdm_private_display*)dpy; + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_display->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); + + fd_source = calloc(1, sizeof(tdm_event_source_fd)); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd_source, TDM_ERROR_OUT_OF_MEMORY, NULL); + + if (mask & TDM_EVENT_READABLE) + wl_mask |= WL_EVENT_READABLE; + if (mask & TDM_EVENT_WRITABLE) + wl_mask |= WL_EVENT_WRITABLE; + + fd_source->base.wl_source = + wl_event_loop_add_fd(private_display->event_loop, + fd, wl_mask, _tdm_event_loop_fd_func, fd_source); + if (!fd_source->base.wl_source) { + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + free(fd_source); + return NULL; + } + + fd_source->private_display = private_display; + fd_source->func = func; + fd_source->user_data = user_data; + + if (error) + *error = TDM_ERROR_NONE; + + return (tdm_event_source*)fd_source; +} + +EXTERN tdm_error +tdm_event_source_fd_update(tdm_event_source *source, tdm_event_mask mask) +{ + tdm_event_source_fd *fd_source = source; + uint32_t wl_mask = 0; + + TDM_RETURN_VAL_IF_FAIL(fd_source, TDM_ERROR_INVALID_PARAMETER); + + if (mask & TDM_EVENT_READABLE) + wl_mask |= WL_EVENT_READABLE; + if (mask & TDM_EVENT_WRITABLE) + wl_mask |= WL_EVENT_WRITABLE; + + if (wl_event_source_fd_update(fd_source->base.wl_source, wl_mask) < 0) { + TDM_ERR("source update failed: %m"); + return TDM_ERROR_OPERATION_FAILED; + } + + return TDM_ERROR_NONE; +} + +static int +_tdm_event_loop_timer_func(void *data) +{ + tdm_event_source_timer *timer_source = (tdm_event_source_timer*)data; + + TDM_RETURN_VAL_IF_FAIL(timer_source, 1); + TDM_RETURN_VAL_IF_FAIL(timer_source->func, 1); + + timer_source->func(timer_source->user_data); + + return 1; +} + +EXTERN tdm_event_source* +tdm_event_add_timer_handler(tdm_display *dpy, tdm_event_timer_handler func, + void *user_data, tdm_error *error) +{ + tdm_private_display *private_display; + tdm_event_source_timer *timer_source; + tdm_error ret; + + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy, TDM_ERROR_INVALID_PARAMETER, NULL); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL); + + private_display = (tdm_private_display*)dpy; + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_display->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); + + timer_source = calloc(1, sizeof(tdm_event_source_timer)); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(timer_source, TDM_ERROR_OUT_OF_MEMORY, NULL); + + timer_source->base.wl_source = + wl_event_loop_add_timer(private_display->event_loop, + _tdm_event_loop_timer_func, timer_source); + if (!timer_source->base.wl_source) { + if (error) + *error = TDM_ERROR_OUT_OF_MEMORY; + free(timer_source); + return NULL; + } + + timer_source->private_display = private_display; + timer_source->func = func; + timer_source->user_data = user_data; + + if (error) + *error = TDM_ERROR_NONE; + + return (tdm_event_source*)timer_source; +} + +EXTERN tdm_error +tdm_event_source_timer_update(tdm_event_source *source, int ms_delay) +{ + tdm_event_source_timer *timer_source = source; + + TDM_RETURN_VAL_IF_FAIL(timer_source, TDM_ERROR_INVALID_PARAMETER); + + if (wl_event_source_timer_update(timer_source->base.wl_source, ms_delay) < 0) { + TDM_ERR("source update failed: %m"); + return TDM_ERROR_OPERATION_FAILED; + } + + return TDM_ERROR_NONE; +} + +EXTERN void +tdm_event_source_remove(tdm_event_source *source) +{ + tdm_event_source_base *base = (tdm_event_source_base*)source; + + if (!base) + return; + + wl_event_source_remove(base->wl_source); + + free(source); +} diff --git a/src/tdm_private.h b/src/tdm_private.h index 15a2448..50396fe 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -51,6 +51,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include +#include #include "tdm_backend.h" #include "tdm_log.h" @@ -190,6 +191,10 @@ struct _tdm_private_display { struct list_head pp_list; void **outputs_ptr; + + /* for event handling */ + struct wl_event_loop *event_loop; + tdm_event_source *main_source; }; struct _tdm_private_output { @@ -311,6 +316,18 @@ tdm_buffer_list_get_first_entry(struct list_head *list); void tdm_buffer_list_dump(struct list_head *list); +/* event functions for private */ +tdm_error +tdm_event_init(tdm_private_display *private_display); +void +tdm_event_deinit(tdm_private_display *private_display); +void +tdm_event_create_main_source(tdm_private_display *private_display); +int +tdm_event_get_fd(tdm_private_display *private_display); +tdm_error +tdm_event_dispatch(tdm_private_display *private_display); + #define _pthread_mutex_lock(l) \ do {if (tdm_debug_mutex) TDM_INFO("mutex lock"); pthread_mutex_lock(l);} while (0) #define _pthread_mutex_unlock(l) \ -- 2.7.4 From 796dd00da47a06b6d4639c24102366a4e54c9f9f Mon Sep 17 00:00:00 2001 From: Boram Park Date: Wed, 30 Mar 2016 09:18:55 +0900 Subject: [PATCH 16/16] Using a wl_display object to create a event loop Change-Id: Id47aa310967328283db7ebb43a326d4305176a49 --- src/tdm_event.c | 104 ++++++++++++++++++++++++++++++++++++++++-------------- src/tdm_private.h | 8 +++-- 2 files changed, 83 insertions(+), 29 deletions(-) diff --git a/src/tdm_event.c b/src/tdm_event.c index 4c5f3a3..e97f2ac 100644 --- a/src/tdm_event.c +++ b/src/tdm_event.c @@ -41,6 +41,14 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tdm_private.h" #include "tdm_list.h" +#include + +struct _tdm_private_event { + struct wl_display *wl_display; + struct wl_event_loop *event_loop; + tdm_event_source *main_source; +}; + typedef struct _tdm_event_source_base { struct wl_event_source *wl_source; @@ -80,17 +88,33 @@ _tdm_event_main_fd_handler(int fd, tdm_event_mask mask, void *user_data) INTERN tdm_error tdm_event_init(tdm_private_display *private_display) { - if (private_display->event_loop) + tdm_private_event *private_event; + + if (private_display->private_event) return TDM_ERROR_NONE; - private_display->event_loop = wl_event_loop_create(); - if (!private_display->event_loop) { - TDM_ERR("creating a event loop failed"); + private_event = calloc(1, sizeof *private_event); + if (!private_event) { + TDM_ERR("alloc failed"); + return TDM_ERROR_OUT_OF_MEMORY; + } + + private_event->wl_display = wl_display_create(); + if (!private_event->wl_display) { + TDM_ERR("creating a wayland display failed"); + free(private_event); + return TDM_ERROR_OUT_OF_MEMORY; + } + + private_event->event_loop = wl_display_get_event_loop(private_event->wl_display); + if (!private_event->event_loop) { + TDM_ERR("no event loop"); + wl_display_destroy(private_event->wl_display); + free(private_event); return TDM_ERROR_OUT_OF_MEMORY; } - TDM_INFO("event_loop fd(%d)", - wl_event_loop_get_fd(private_display->event_loop)); + private_display->private_event = private_event; return TDM_ERROR_NONE; } @@ -98,24 +122,29 @@ tdm_event_init(tdm_private_display *private_display) INTERN void tdm_event_deinit(tdm_private_display *private_display) { - if (private_display->main_source) { - tdm_event_source_remove(private_display->main_source); - private_display->main_source = NULL; - } + if (!private_display->private_event) + return; - if (private_display->event_loop) { - wl_event_loop_destroy(private_display->event_loop); - private_display->event_loop = NULL; - } + if (private_display->private_event->main_source) + tdm_event_source_remove(private_display->private_event->main_source); + + if (private_display->private_event->wl_display) + wl_display_destroy(private_display->private_event->wl_display); + + free(private_display->private_event); + private_display->private_event = NULL; } INTERN void tdm_event_create_main_source(tdm_private_display *private_display) { + tdm_private_event *private_event = private_display->private_event; tdm_func_display *func_display; tdm_error ret; int fd = -1; + TDM_RETURN_IF_FAIL(private_event != NULL); + func_display = &private_display->func_display; if (!func_display->display_get_fd) { TDM_INFO("TDM backend module won't offer a display fd"); @@ -133,11 +162,11 @@ tdm_event_create_main_source(tdm_private_display *private_display) return; } - private_display->main_source = + private_event->main_source = tdm_event_add_fd_handler(private_display, fd, TDM_EVENT_READABLE, _tdm_event_main_fd_handler, private_display, &ret); - if (!private_display->main_source) { + if (!private_event->main_source) { TDM_ERR("no main event source"); return; } @@ -148,19 +177,21 @@ tdm_event_create_main_source(tdm_private_display *private_display) INTERN int tdm_event_get_fd(tdm_private_display *private_display) { - if (!private_display->event_loop) - return -1; + tdm_private_event *private_event = private_display->private_event; + + TDM_RETURN_VAL_IF_FAIL(private_event->event_loop != NULL, -1); - return wl_event_loop_get_fd(private_display->event_loop); + return wl_event_loop_get_fd(private_event->event_loop); } INTERN tdm_error tdm_event_dispatch(tdm_private_display *private_display) { - if (!private_display->event_loop) - return TDM_ERROR_NONE; + tdm_private_event *private_event = private_display->private_event; + + TDM_RETURN_VAL_IF_FAIL(private_event->event_loop != NULL, TDM_ERROR_OPERATION_FAILED); - if (wl_event_loop_dispatch(private_display->event_loop, 0) < 0) { + if (wl_event_loop_dispatch(private_event->event_loop, 0) < 0) { TDM_ERR("dispatch failed"); return TDM_ERROR_OPERATION_FAILED; } @@ -168,6 +199,21 @@ tdm_event_dispatch(tdm_private_display *private_display) return TDM_ERROR_NONE; } +INTERN tdm_error +tdm_event_add_socket(tdm_private_display *private_display, const char *name) +{ + tdm_private_event *private_event = private_display->private_event; + + TDM_RETURN_VAL_IF_FAIL(private_event->wl_display != NULL, TDM_ERROR_OPERATION_FAILED); + + if (wl_display_add_socket(private_event->wl_display, name) < 0) { + TDM_ERR("add socket(\"%s\") failed", name); + return TDM_ERROR_OPERATION_FAILED; + } + + return TDM_ERROR_NONE; +} + static int _tdm_event_loop_fd_func(int fd, uint32_t wl_mask, void *data) { @@ -197,6 +243,7 @@ tdm_event_add_fd_handler(tdm_display *dpy, int fd, tdm_event_mask mask, tdm_error *error) { tdm_private_display *private_display; + tdm_private_event *private_event; tdm_event_source_fd *fd_source; uint32_t wl_mask = 0; tdm_error ret; @@ -206,7 +253,9 @@ tdm_event_add_fd_handler(tdm_display *dpy, int fd, tdm_event_mask mask, TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL); private_display = (tdm_private_display*)dpy; - TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_display->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); + private_event = private_display->private_event; + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_event, TDM_ERROR_INVALID_PARAMETER, NULL); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_event->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); fd_source = calloc(1, sizeof(tdm_event_source_fd)); TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(fd_source, TDM_ERROR_OUT_OF_MEMORY, NULL); @@ -217,7 +266,7 @@ tdm_event_add_fd_handler(tdm_display *dpy, int fd, tdm_event_mask mask, wl_mask |= WL_EVENT_WRITABLE; fd_source->base.wl_source = - wl_event_loop_add_fd(private_display->event_loop, + wl_event_loop_add_fd(private_event->event_loop, fd, wl_mask, _tdm_event_loop_fd_func, fd_source); if (!fd_source->base.wl_source) { if (error) @@ -275,6 +324,7 @@ tdm_event_add_timer_handler(tdm_display *dpy, tdm_event_timer_handler func, void *user_data, tdm_error *error) { tdm_private_display *private_display; + tdm_private_event *private_event; tdm_event_source_timer *timer_source; tdm_error ret; @@ -282,13 +332,15 @@ tdm_event_add_timer_handler(tdm_display *dpy, tdm_event_timer_handler func, TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(func, TDM_ERROR_INVALID_PARAMETER, NULL); private_display = (tdm_private_display*)dpy; - TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_display->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); + private_event = private_display->private_event; + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_event, TDM_ERROR_INVALID_PARAMETER, NULL); + TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_event->event_loop, TDM_ERROR_INVALID_PARAMETER, NULL); timer_source = calloc(1, sizeof(tdm_event_source_timer)); TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(timer_source, TDM_ERROR_OUT_OF_MEMORY, NULL); timer_source->base.wl_source = - wl_event_loop_add_timer(private_display->event_loop, + wl_event_loop_add_timer(private_event->event_loop, _tdm_event_loop_timer_func, timer_source); if (!timer_source->base.wl_source) { if (error) diff --git a/src/tdm_private.h b/src/tdm_private.h index 50396fe..1c0009d 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -51,7 +51,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include #include -#include #include "tdm_backend.h" #include "tdm_log.h" @@ -161,6 +160,7 @@ typedef struct _tdm_private_output tdm_private_output; typedef struct _tdm_private_layer tdm_private_layer; typedef struct _tdm_private_pp tdm_private_pp; typedef struct _tdm_private_capture tdm_private_capture; +typedef struct _tdm_private_event tdm_private_event; typedef struct _tdm_private_vblank_handler tdm_private_vblank_handler; typedef struct _tdm_private_commit_handler tdm_private_commit_handler; @@ -193,8 +193,7 @@ struct _tdm_private_display { void **outputs_ptr; /* for event handling */ - struct wl_event_loop *event_loop; - tdm_event_source *main_source; + tdm_private_event *private_event; }; struct _tdm_private_output { @@ -327,6 +326,9 @@ int tdm_event_get_fd(tdm_private_display *private_display); tdm_error tdm_event_dispatch(tdm_private_display *private_display); +tdm_error +tdm_event_add_socket(tdm_private_display *private_display, const char *name); + #define _pthread_mutex_lock(l) \ do {if (tdm_debug_mutex) TDM_INFO("mutex lock"); pthread_mutex_lock(l);} while (0) -- 2.7.4