1 /**************************************************************************
5 Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
7 Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8 JinYoung Jeon <jy0.jeon@samsung.com>,
9 Taeheon Kim <th908.kim@samsung.com>,
10 YoungJun Cho <yj44.cho@samsung.com>,
11 SooChan Lim <sc1.lim@samsung.com>,
12 Boram Park <sc1.lim@samsung.com>
14 Permission is hereby granted, free of charge, to any person obtaining a
15 copy of this software and associated documentation files (the
16 "Software"), to deal in the Software without restriction, including
17 without limitation the rights to use, copy, modify, merge, publish,
18 distribute, sub license, and/or sell copies of the Software, and to
19 permit persons to whom the Software is furnished to do so, subject to
20 the following conditions:
22 The above copyright notice and this permission notice (including the
23 next paragraph) shall be included in all copies or substantial portions
26 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 **************************************************************************/
41 #include "tdm_backend.h"
42 #include "tdm_private.h"
46 #define DISPLAY_FUNC_ENTRY() \
47 tdm_private_display *private_display; \
48 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
49 TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
50 private_display = (tdm_private_display*)dpy;
52 #define DISPLAY_FUNC_ENTRY_ERROR() \
53 tdm_private_display *private_display; \
54 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
55 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
56 private_display = (tdm_private_display*)dpy;
58 #define OUTPUT_FUNC_ENTRY() \
59 tdm_private_display *private_display; \
60 tdm_private_output *private_output; \
61 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
62 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); \
63 private_output = (tdm_private_output*)output; \
64 private_display = private_output->private_display
66 #define OUTPUT_FUNC_ENTRY_ERROR() \
67 tdm_private_display *private_display; \
68 tdm_private_output *private_output; \
69 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
70 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
71 private_output = (tdm_private_output*)output; \
72 private_display = private_output->private_display
74 #define LAYER_FUNC_ENTRY() \
75 tdm_private_display *private_display; \
76 tdm_private_output *private_output; \
77 tdm_private_layer *private_layer; \
78 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
79 TDM_RETURN_VAL_IF_FAIL(layer != NULL, TDM_ERROR_INVALID_PARAMETER); \
80 private_layer = (tdm_private_layer*)layer; \
81 private_output = private_layer->private_output; \
82 private_display = private_output->private_display
84 #define LAYER_FUNC_ENTRY_ERROR() \
85 tdm_private_display *private_display; \
86 tdm_private_output *private_output; \
87 tdm_private_layer *private_layer; \
88 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
89 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(layer != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
90 private_layer = (tdm_private_layer*)layer; \
91 private_output = private_layer->private_output; \
92 private_display = private_output->private_display
95 tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities)
99 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
101 pthread_mutex_lock(&private_display->lock);
103 *capabilities = private_display->capabilities;
105 pthread_mutex_unlock(&private_display->lock);
111 tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities)
113 DISPLAY_FUNC_ENTRY();
115 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
117 pthread_mutex_lock(&private_display->lock);
119 *capabilities = private_display->caps_pp.capabilities;
121 pthread_mutex_unlock(&private_display->lock);
127 tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
129 DISPLAY_FUNC_ENTRY();
131 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
132 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
134 pthread_mutex_lock(&private_display->lock);
136 *formats = (const tbm_format*)private_display->caps_pp.formats;
137 *count = private_display->caps_pp.format_count;
139 pthread_mutex_unlock(&private_display->lock);
145 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h, int *max_w, int *max_h, int *preferred_align)
147 DISPLAY_FUNC_ENTRY();
149 pthread_mutex_lock(&private_display->lock);
152 *min_w = private_display->caps_pp.min_w;
154 *min_h = private_display->caps_pp.min_h;
156 *max_w = private_display->caps_pp.max_w;
158 *max_h = private_display->caps_pp.max_h;
160 *preferred_align = private_display->caps_pp.preferred_align;
162 pthread_mutex_unlock(&private_display->lock);
168 tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
170 DISPLAY_FUNC_ENTRY();
172 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
174 pthread_mutex_lock(&private_display->lock);
176 *capabilities = private_display->caps_capture.capabilities;
178 pthread_mutex_unlock(&private_display->lock);
184 tdm_display_get_catpure_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
186 DISPLAY_FUNC_ENTRY();
188 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
189 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
191 pthread_mutex_lock(&private_display->lock);
193 *formats = (const tbm_format*)private_display->caps_capture.formats;
194 *count = private_display->caps_capture.format_count;
196 pthread_mutex_unlock(&private_display->lock);
202 tdm_display_get_output_count(tdm_display *dpy, int *count)
204 tdm_private_output *private_output = NULL;
206 DISPLAY_FUNC_ENTRY();
208 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
210 pthread_mutex_lock(&private_display->lock);
213 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
218 pthread_mutex_unlock(&private_display->lock);
219 return TDM_ERROR_NONE;
222 pthread_mutex_unlock(&private_display->lock);
228 EXTERN const tdm_output*
229 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
231 tdm_private_output *private_output = NULL;
234 DISPLAY_FUNC_ENTRY_ERROR();
236 pthread_mutex_lock(&private_display->lock);
239 *error = TDM_ERROR_NONE;
242 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
246 pthread_mutex_unlock(&private_display->lock);
247 return (const tdm_output*)private_output;
252 pthread_mutex_unlock(&private_display->lock);
258 tdm_display_get_fd(tdm_display *dpy, int *fd)
260 tdm_func_display *func_display;
261 DISPLAY_FUNC_ENTRY();
263 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
265 pthread_mutex_lock(&private_display->lock);
267 func_display = &private_display->func_display;
269 if (!func_display->display_get_fd)
271 pthread_mutex_unlock(&private_display->lock);
272 return TDM_ERROR_NONE;
275 ret = func_display->display_get_fd(private_display->bdata, fd);
277 pthread_mutex_unlock(&private_display->lock);
283 tdm_display_handle_events(tdm_display *dpy)
285 tdm_func_display *func_display;
286 DISPLAY_FUNC_ENTRY();
288 pthread_mutex_lock(&private_display->lock);
290 func_display = &private_display->func_display;
292 if (!func_display->display_handle_events)
294 pthread_mutex_unlock(&private_display->lock);
295 return TDM_ERROR_NONE;
298 ret = func_display->display_handle_events(private_display->bdata);
300 pthread_mutex_unlock(&private_display->lock);
306 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
310 DISPLAY_FUNC_ENTRY_ERROR();
312 pthread_mutex_lock(&private_display->lock);
314 pp = (tdm_pp*)tdm_pp_create_internal(private_display, error);
316 pthread_mutex_unlock(&private_display->lock);
322 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
326 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
328 pthread_mutex_lock(&private_display->lock);
330 *status = private_output->caps.status;
332 pthread_mutex_unlock(&private_display->lock);
338 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
342 TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
344 pthread_mutex_lock(&private_display->lock);
346 *type = private_output->caps.type;
348 pthread_mutex_unlock(&private_display->lock);
354 tdm_output_get_layer_count(tdm_output *output, int *count)
356 tdm_private_layer *private_layer = NULL;
360 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
362 pthread_mutex_lock(&private_display->lock);
365 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
369 pthread_mutex_unlock(&private_display->lock);
370 return TDM_ERROR_NONE;
373 pthread_mutex_unlock(&private_display->lock);
379 EXTERN const tdm_layer*
380 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
382 tdm_private_layer *private_layer = NULL;
385 OUTPUT_FUNC_ENTRY_ERROR();
387 pthread_mutex_lock(&private_display->lock);
390 *error = TDM_ERROR_NONE;
392 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
396 pthread_mutex_unlock(&private_display->lock);
397 return private_layer;
402 pthread_mutex_unlock(&private_display->lock);
408 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, int *count)
412 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
413 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
415 pthread_mutex_lock(&private_display->lock);
417 *props = (const tdm_prop*)private_output->caps.props;
418 *count = private_output->caps.prop_count;
420 pthread_mutex_unlock(&private_display->lock);
426 tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes, int *count)
430 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
431 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
433 pthread_mutex_lock(&private_display->lock);
435 *modes = (const tdm_output_mode*)private_output->caps.modes;
436 *count = private_output->caps.mode_count;
438 pthread_mutex_unlock(&private_display->lock);
444 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h, int *max_w, int *max_h, int *preferred_align)
448 pthread_mutex_lock(&private_display->lock);
451 *min_w = private_output->caps.min_w;
453 *min_h = private_output->caps.min_h;
455 *max_w = private_output->caps.max_w;
457 *max_h = private_output->caps.max_h;
459 *preferred_align = private_output->caps.preferred_align;
461 pthread_mutex_unlock(&private_display->lock);
467 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, unsigned int *mmHeight)
471 pthread_mutex_lock(&private_display->lock);
474 *mmWidth = private_output->caps.mmWidth;
476 *mmHeight = private_output->caps.mmHeight;
478 pthread_mutex_unlock(&private_display->lock);
484 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
487 TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
489 pthread_mutex_lock(&private_display->lock);
491 *subpixel = private_output->caps.subpixel;
493 pthread_mutex_unlock(&private_display->lock);
499 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
502 TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
504 pthread_mutex_lock(&private_display->lock);
506 *pipe = private_output->pipe;
508 pthread_mutex_unlock(&private_display->lock);
515 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
517 tdm_func_display *func_display;
520 pthread_mutex_lock(&private_display->lock);
522 func_display = &private_display->func_display;
524 if (!func_display->output_set_property)
526 pthread_mutex_unlock(&private_display->lock);
527 return TDM_ERROR_NONE;
530 ret = func_display->output_set_property(private_output->output, id, value);
532 pthread_mutex_unlock(&private_display->lock);
538 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
540 tdm_func_display *func_display;
543 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
545 pthread_mutex_lock(&private_display->lock);
547 func_display = &private_display->func_display;
549 if (!func_display->output_get_property)
551 pthread_mutex_unlock(&private_display->lock);
552 return TDM_ERROR_NONE;
555 ret = func_display->output_get_property(private_output->output, id, value);
557 pthread_mutex_unlock(&private_display->lock);
563 _tdm_output_cb_vblank(tdm_output *output, unsigned int sequence,
564 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
566 tdm_private_output *private_output = output;
567 tdm_private_vblank_handler *vblank_handler = user_data;
569 TDM_RETURN_IF_FAIL(private_output);
570 TDM_RETURN_IF_FAIL(vblank_handler);
572 if (vblank_handler->func)
573 vblank_handler->func(private_output, sequence, tv_sec, tv_usec, vblank_handler->user_data);
575 LIST_DEL(&vblank_handler->link);
576 free(vblank_handler);
580 _tdm_output_cb_commit(tdm_output *output, unsigned int sequence,
581 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
583 tdm_private_output *private_output = output;
584 tdm_private_commit_handler *commit_handler = user_data;
586 TDM_RETURN_IF_FAIL(private_output);
587 TDM_RETURN_IF_FAIL(commit_handler);
589 if (commit_handler->func)
590 commit_handler->func(private_output, sequence, tv_sec, tv_usec, commit_handler->user_data);
592 LIST_DEL(&commit_handler->link);
593 free(commit_handler);
597 tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vblank_handler func, void *user_data)
599 tdm_func_display *func_display;
600 tdm_private_vblank_handler *vblank_handler;
603 pthread_mutex_lock(&private_display->lock);
605 func_display = &private_display->func_display;
607 if (!func_display->output_wait_vblank)
609 pthread_mutex_unlock(&private_display->lock);
610 return TDM_ERROR_NONE;
613 vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
616 TDM_ERR("failed: alloc memory");
617 pthread_mutex_unlock(&private_display->lock);
618 return TDM_ERROR_OUT_OF_MEMORY;
621 LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
622 vblank_handler->func = func;
623 vblank_handler->user_data = user_data;
625 ret = func_display->output_wait_vblank(private_output->output, interval, sync, vblank_handler);
626 if (ret != TDM_ERROR_NONE)
628 pthread_mutex_unlock(&private_display->lock);
632 if (!private_output->regist_vblank_cb)
634 private_output->regist_vblank_cb = 1;
635 ret = func_display->output_set_vblank_handler(private_output->output, _tdm_output_cb_vblank);
638 pthread_mutex_unlock(&private_display->lock);
644 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
646 tdm_func_display *func_display;
647 tdm_private_commit_handler *commit_handler;
650 pthread_mutex_lock(&private_display->lock);
652 func_display = &private_display->func_display;
654 if (!func_display->output_commit)
656 pthread_mutex_unlock(&private_display->lock);
657 return TDM_ERROR_NONE;
660 commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
663 TDM_ERR("failed: alloc memory");
664 pthread_mutex_unlock(&private_display->lock);
665 return TDM_ERROR_OUT_OF_MEMORY;
668 LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
669 commit_handler->func = func;
670 commit_handler->user_data = user_data;
672 ret = func_display->output_commit(private_output->output, sync, commit_handler);
673 if (ret != TDM_ERROR_NONE)
675 pthread_mutex_unlock(&private_display->lock);
679 if (!private_output->regist_commit_cb)
681 private_output->regist_commit_cb = 1;
682 ret = func_display->output_set_commit_handler(private_output->output, _tdm_output_cb_commit);
685 pthread_mutex_unlock(&private_display->lock);
691 tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
693 tdm_func_display *func_display;
696 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
698 pthread_mutex_lock(&private_display->lock);
700 func_display = &private_display->func_display;
702 if (!func_display->output_set_mode)
704 pthread_mutex_unlock(&private_display->lock);
705 return TDM_ERROR_NONE;
708 ret = func_display->output_set_mode(private_output->output, mode);
710 pthread_mutex_unlock(&private_display->lock);
716 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
718 tdm_func_display *func_display;
721 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
723 pthread_mutex_lock(&private_display->lock);
725 func_display = &private_display->func_display;
727 if (!func_display->output_get_mode)
729 pthread_mutex_unlock(&private_display->lock);
730 return TDM_ERROR_NONE;
733 ret = func_display->output_get_mode(private_output->output, mode);
735 pthread_mutex_unlock(&private_display->lock);
741 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
743 tdm_func_display *func_display;
746 TDM_RETURN_VAL_IF_FAIL(dpms_value >= TDM_OUTPUT_DPMS_ON, TDM_ERROR_INVALID_PARAMETER);
747 TDM_RETURN_VAL_IF_FAIL(dpms_value < TDM_OUTPUT_DPMS_MAX, TDM_ERROR_INVALID_PARAMETER);
749 pthread_mutex_lock(&private_display->lock);
751 func_display = &private_display->func_display;
753 if (!func_display->output_set_dpms)
755 pthread_mutex_unlock(&private_display->lock);
756 return TDM_ERROR_NONE;
759 ret = func_display->output_set_dpms(private_output->output, dpms_value);
761 pthread_mutex_unlock(&private_display->lock);
767 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
769 tdm_func_display *func_display;
772 TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
774 pthread_mutex_lock(&private_display->lock);
776 func_display = &private_display->func_display;
778 if (!func_display->output_get_dpms)
780 pthread_mutex_unlock(&private_display->lock);
781 return TDM_ERROR_NONE;
784 ret = func_display->output_get_dpms(private_output->output, dpms_value);
786 pthread_mutex_unlock(&private_display->lock);
792 tdm_output_create_capture(tdm_output *output, tdm_error *error)
794 tdm_capture *capture = NULL;
796 OUTPUT_FUNC_ENTRY_ERROR();
798 pthread_mutex_lock(&private_display->lock);
800 capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
802 pthread_mutex_unlock(&private_display->lock);
808 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
812 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
814 pthread_mutex_lock(&private_display->lock);
816 *capabilities = private_layer->caps.capabilities;
818 pthread_mutex_unlock(&private_display->lock);
824 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
828 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
829 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
831 pthread_mutex_lock(&private_display->lock);
833 *formats = (const tbm_format*)private_layer->caps.formats;
834 *count = private_layer->caps.format_count;
836 pthread_mutex_unlock(&private_display->lock);
842 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
846 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
847 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
849 pthread_mutex_lock(&private_display->lock);
851 *props = (const tdm_prop*)private_layer->caps.props;
852 *count = private_layer->caps.prop_count;
854 pthread_mutex_unlock(&private_display->lock);
860 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
864 TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
866 pthread_mutex_lock(&private_display->lock);
868 *zpos = private_layer->caps.zpos;
870 pthread_mutex_unlock(&private_display->lock);
876 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
878 tdm_func_display *func_display;
881 pthread_mutex_lock(&private_display->lock);
883 func_display = &private_display->func_display;
885 if (!func_display->layer_set_property)
887 pthread_mutex_unlock(&private_display->lock);
888 return TDM_ERROR_NONE;
891 ret = func_display->layer_set_property(private_layer->layer, id, value);
893 pthread_mutex_unlock(&private_display->lock);
899 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
901 tdm_func_display *func_display;
904 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
906 pthread_mutex_lock(&private_display->lock);
908 func_display = &private_display->func_display;
910 if (!func_display->layer_get_property)
912 pthread_mutex_unlock(&private_display->lock);
913 return TDM_ERROR_NONE;
916 ret = func_display->layer_get_property(private_layer->layer, id, value);
918 pthread_mutex_unlock(&private_display->lock);
924 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
926 tdm_func_display *func_display;
929 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
931 pthread_mutex_lock(&private_display->lock);
933 func_display = &private_display->func_display;
935 private_layer->usable = 0;
937 if (!func_display->layer_set_info)
939 pthread_mutex_unlock(&private_display->lock);
940 return TDM_ERROR_NONE;
943 ret = func_display->layer_set_info(private_layer->layer, info);
945 pthread_mutex_unlock(&private_display->lock);
951 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
953 tdm_func_display *func_display;
956 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
958 pthread_mutex_lock(&private_display->lock);
960 func_display = &private_display->func_display;
962 if (!func_display->layer_get_info)
964 pthread_mutex_unlock(&private_display->lock);
965 return TDM_ERROR_NONE;
968 ret = func_display->layer_get_info(private_layer->layer, info);
970 pthread_mutex_unlock(&private_display->lock);
976 tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
978 tdm_func_display *func_display;
981 TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
983 pthread_mutex_lock(&private_display->lock);
985 func_display = &private_display->func_display;
987 private_layer->usable = 0;
989 if (!func_display->layer_set_buffer)
991 pthread_mutex_unlock(&private_display->lock);
992 return TDM_ERROR_NONE;
995 if (private_layer->current_buffer)
997 /* TODO: need to unref after next buffer is showing on screen */
998 tdm_buffer_unref_backend(private_layer->current_buffer);
999 tdm_buffer_unref(private_layer->current_buffer);
1002 private_layer->current_buffer = tdm_buffer_ref(buffer, NULL);
1003 tdm_buffer_ref_backend(buffer);
1005 ret = func_display->layer_set_buffer(private_layer->layer,
1006 tdm_buffer_get_surface(buffer));
1008 pthread_mutex_unlock(&private_display->lock);
1014 tdm_layer_unset_buffer(tdm_layer *layer)
1016 tdm_func_display *func_display;
1019 pthread_mutex_lock(&private_display->lock);
1021 func_display = &private_display->func_display;
1023 if (private_layer->current_buffer)
1025 tdm_buffer_unref(private_layer->current_buffer);
1026 tdm_buffer_unref_backend(private_layer->current_buffer);
1027 private_layer->current_buffer = NULL;
1030 private_layer->usable = 1;
1032 if (!func_display->layer_unset_buffer)
1034 pthread_mutex_unlock(&private_display->lock);
1035 return TDM_ERROR_NONE;
1038 ret = func_display->layer_unset_buffer(private_layer->layer);
1040 pthread_mutex_unlock(&private_display->lock);
1046 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1050 TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1052 pthread_mutex_lock(&private_display->lock);
1054 *usable = private_layer->usable;
1056 pthread_mutex_unlock(&private_display->lock);
1063 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1065 tdm_capture *capture = NULL;
1067 LAYER_FUNC_ENTRY_ERROR();
1069 pthread_mutex_lock(&private_display->lock);
1071 capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
1073 pthread_mutex_unlock(&private_display->lock);