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_pp_available_properties(tdm_display *dpy, const tdm_prop **props, int *count)
170 DISPLAY_FUNC_ENTRY();
172 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
173 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
175 pthread_mutex_lock(&private_display->lock);
177 *props = (const tdm_prop*)private_display->caps_pp.props;
178 *count = private_display->caps_pp.format_count;
180 pthread_mutex_unlock(&private_display->lock);
186 tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
188 DISPLAY_FUNC_ENTRY();
190 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
192 pthread_mutex_lock(&private_display->lock);
194 *capabilities = private_display->caps_capture.capabilities;
196 pthread_mutex_unlock(&private_display->lock);
202 tdm_display_get_catpure_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
204 DISPLAY_FUNC_ENTRY();
206 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
207 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
209 pthread_mutex_lock(&private_display->lock);
211 *formats = (const tbm_format*)private_display->caps_capture.formats;
212 *count = private_display->caps_capture.format_count;
214 pthread_mutex_unlock(&private_display->lock);
220 tdm_display_get_output_count(tdm_display *dpy, int *count)
222 tdm_private_output *private_output = NULL;
224 DISPLAY_FUNC_ENTRY();
226 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
228 pthread_mutex_lock(&private_display->lock);
231 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
236 pthread_mutex_unlock(&private_display->lock);
237 return TDM_ERROR_NONE;
240 pthread_mutex_unlock(&private_display->lock);
246 EXTERN const tdm_output*
247 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
249 tdm_private_output *private_output = NULL;
252 DISPLAY_FUNC_ENTRY_ERROR();
254 pthread_mutex_lock(&private_display->lock);
257 *error = TDM_ERROR_NONE;
260 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
264 pthread_mutex_unlock(&private_display->lock);
265 return (const tdm_output*)private_output;
270 pthread_mutex_unlock(&private_display->lock);
276 tdm_display_get_fd(tdm_display *dpy, int *fd)
278 tdm_func_display *func_display;
279 DISPLAY_FUNC_ENTRY();
281 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
283 pthread_mutex_lock(&private_display->lock);
285 func_display = &private_display->func_display;
287 if (!func_display->display_get_fd)
289 pthread_mutex_unlock(&private_display->lock);
290 return TDM_ERROR_NONE;
293 ret = func_display->display_get_fd(private_display->bdata, fd);
295 pthread_mutex_unlock(&private_display->lock);
301 tdm_display_handle_events(tdm_display *dpy)
303 tdm_func_display *func_display;
304 DISPLAY_FUNC_ENTRY();
306 pthread_mutex_lock(&private_display->lock);
308 func_display = &private_display->func_display;
310 if (!func_display->display_handle_events)
312 pthread_mutex_unlock(&private_display->lock);
313 return TDM_ERROR_NONE;
316 ret = func_display->display_handle_events(private_display->bdata);
318 pthread_mutex_unlock(&private_display->lock);
324 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
328 DISPLAY_FUNC_ENTRY_ERROR();
330 pthread_mutex_lock(&private_display->lock);
332 pp = (tdm_pp*)tdm_pp_create_internal(private_display, error);
334 pthread_mutex_unlock(&private_display->lock);
340 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
344 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
346 pthread_mutex_lock(&private_display->lock);
348 *status = private_output->caps.status;
350 pthread_mutex_unlock(&private_display->lock);
356 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
360 TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
362 pthread_mutex_lock(&private_display->lock);
364 *type = private_output->caps.type;
366 pthread_mutex_unlock(&private_display->lock);
372 tdm_output_get_layer_count(tdm_output *output, int *count)
374 tdm_private_layer *private_layer = NULL;
378 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
380 pthread_mutex_lock(&private_display->lock);
383 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
387 pthread_mutex_unlock(&private_display->lock);
388 return TDM_ERROR_NONE;
391 pthread_mutex_unlock(&private_display->lock);
397 EXTERN const tdm_layer*
398 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
400 tdm_private_layer *private_layer = NULL;
403 OUTPUT_FUNC_ENTRY_ERROR();
405 pthread_mutex_lock(&private_display->lock);
408 *error = TDM_ERROR_NONE;
410 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
414 pthread_mutex_unlock(&private_display->lock);
415 return private_layer;
420 pthread_mutex_unlock(&private_display->lock);
426 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, int *count)
430 TDM_RETURN_VAL_IF_FAIL(props != 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 *props = (const tdm_prop*)private_output->caps.props;
436 *count = private_output->caps.prop_count;
438 pthread_mutex_unlock(&private_display->lock);
444 tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes, int *count)
448 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
449 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
451 pthread_mutex_lock(&private_display->lock);
453 *modes = (const tdm_output_mode*)private_output->caps.modes;
454 *count = private_output->caps.mode_count;
456 pthread_mutex_unlock(&private_display->lock);
462 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h, int *max_w, int *max_h, int *preferred_align)
466 pthread_mutex_lock(&private_display->lock);
469 *min_w = private_output->caps.min_w;
471 *min_h = private_output->caps.min_h;
473 *max_w = private_output->caps.max_w;
475 *max_h = private_output->caps.max_h;
477 *preferred_align = private_output->caps.preferred_align;
479 pthread_mutex_unlock(&private_display->lock);
485 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, unsigned int *mmHeight)
489 pthread_mutex_lock(&private_display->lock);
492 *mmWidth = private_output->caps.mmWidth;
494 *mmHeight = private_output->caps.mmHeight;
496 pthread_mutex_unlock(&private_display->lock);
502 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
506 pthread_mutex_lock(&private_display->lock);
509 *subpixel = private_output->caps.subpixel;
511 pthread_mutex_unlock(&private_display->lock);
517 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
519 tdm_func_display *func_display;
522 pthread_mutex_lock(&private_display->lock);
524 func_display = &private_display->func_display;
526 if (!func_display->output_set_property)
528 pthread_mutex_unlock(&private_display->lock);
529 return TDM_ERROR_NONE;
532 ret = func_display->output_set_property(private_output->output, id, value);
534 pthread_mutex_unlock(&private_display->lock);
540 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
542 tdm_func_display *func_display;
545 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
547 pthread_mutex_lock(&private_display->lock);
549 func_display = &private_display->func_display;
551 if (!func_display->output_get_property)
553 pthread_mutex_unlock(&private_display->lock);
554 return TDM_ERROR_NONE;
557 ret = func_display->output_get_property(private_output->output, id, value);
559 pthread_mutex_unlock(&private_display->lock);
565 _tdm_output_cb_vblank(tdm_output *output, unsigned int sequence,
566 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
568 tdm_private_output *private_output = output;
569 tdm_private_vblank_handler *vblank_handler = user_data;
571 TDM_RETURN_IF_FAIL(private_output);
572 TDM_RETURN_IF_FAIL(vblank_handler);
574 if (vblank_handler->func)
575 vblank_handler->func(private_output, sequence, tv_sec, tv_usec, vblank_handler->user_data);
577 LIST_DEL(&vblank_handler->link);
578 free(vblank_handler);
582 _tdm_output_cb_commit(tdm_output *output, unsigned int sequence,
583 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
585 tdm_private_output *private_output = output;
586 tdm_private_commit_handler *commit_handler = user_data;
588 TDM_RETURN_IF_FAIL(private_output);
589 TDM_RETURN_IF_FAIL(commit_handler);
591 if (commit_handler->func)
592 commit_handler->func(private_output, sequence, tv_sec, tv_usec, commit_handler->user_data);
594 LIST_DEL(&commit_handler->link);
595 free(commit_handler);
599 tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vblank_handler func, void *user_data)
601 tdm_func_display *func_display;
602 tdm_private_vblank_handler *vblank_handler;
605 pthread_mutex_lock(&private_display->lock);
607 func_display = &private_display->func_display;
609 if (!func_display->output_wait_vblank)
611 pthread_mutex_unlock(&private_display->lock);
612 return TDM_ERROR_NONE;
615 vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
618 TDM_ERR("failed: alloc memory");
619 pthread_mutex_unlock(&private_display->lock);
620 return TDM_ERROR_OUT_OF_MEMORY;
623 LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
624 vblank_handler->func = func;
625 vblank_handler->user_data = user_data;
627 ret = func_display->output_wait_vblank(private_output->output, interval, sync, vblank_handler);
628 if (ret != TDM_ERROR_NONE)
630 pthread_mutex_unlock(&private_display->lock);
634 if (!private_output->regist_vblank_cb)
636 private_output->regist_vblank_cb = 1;
637 ret = func_display->output_set_vblank_handler(private_output->output, _tdm_output_cb_vblank);
640 pthread_mutex_unlock(&private_display->lock);
646 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
648 tdm_func_display *func_display;
649 tdm_private_commit_handler *commit_handler;
652 pthread_mutex_lock(&private_display->lock);
654 func_display = &private_display->func_display;
656 if (!func_display->output_commit)
658 pthread_mutex_unlock(&private_display->lock);
659 return TDM_ERROR_NONE;
662 commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
665 TDM_ERR("failed: alloc memory");
666 pthread_mutex_unlock(&private_display->lock);
667 return TDM_ERROR_OUT_OF_MEMORY;
670 LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
671 commit_handler->func = func;
672 commit_handler->user_data = user_data;
674 ret = func_display->output_commit(private_output->output, sync, commit_handler);
675 if (ret != TDM_ERROR_NONE)
677 pthread_mutex_unlock(&private_display->lock);
681 if (!private_output->regist_commit_cb)
683 private_output->regist_commit_cb = 1;
684 ret = func_display->output_set_commit_handler(private_output->output, _tdm_output_cb_commit);
687 pthread_mutex_unlock(&private_display->lock);
693 tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
695 tdm_func_display *func_display;
698 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
700 pthread_mutex_lock(&private_display->lock);
702 func_display = &private_display->func_display;
704 if (!func_display->output_set_mode)
706 pthread_mutex_unlock(&private_display->lock);
707 return TDM_ERROR_NONE;
710 ret = func_display->output_set_mode(private_output->output, mode);
712 pthread_mutex_unlock(&private_display->lock);
718 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
720 tdm_func_display *func_display;
723 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
725 pthread_mutex_lock(&private_display->lock);
727 func_display = &private_display->func_display;
729 if (!func_display->output_get_mode)
731 pthread_mutex_unlock(&private_display->lock);
732 return TDM_ERROR_NONE;
735 ret = func_display->output_get_mode(private_output->output, mode);
737 pthread_mutex_unlock(&private_display->lock);
743 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
745 tdm_func_display *func_display;
748 TDM_RETURN_VAL_IF_FAIL(dpms_value >= TDM_OUTPUT_DPMS_ON, TDM_ERROR_INVALID_PARAMETER);
749 TDM_RETURN_VAL_IF_FAIL(dpms_value < TDM_OUTPUT_DPMS_MAX, TDM_ERROR_INVALID_PARAMETER);
751 pthread_mutex_lock(&private_display->lock);
753 func_display = &private_display->func_display;
755 if (!func_display->output_set_dpms)
757 pthread_mutex_unlock(&private_display->lock);
758 return TDM_ERROR_NONE;
761 ret = func_display->output_set_dpms(private_output->output, dpms_value);
763 pthread_mutex_unlock(&private_display->lock);
769 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
771 tdm_func_display *func_display;
774 TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
776 pthread_mutex_lock(&private_display->lock);
778 func_display = &private_display->func_display;
780 if (!func_display->output_get_dpms)
782 pthread_mutex_unlock(&private_display->lock);
783 return TDM_ERROR_NONE;
786 ret = func_display->output_get_dpms(private_output->output, dpms_value);
788 pthread_mutex_unlock(&private_display->lock);
794 tdm_output_create_capture(tdm_output *output, tdm_error *error)
796 tdm_capture *capture = NULL;
798 OUTPUT_FUNC_ENTRY_ERROR();
800 pthread_mutex_lock(&private_display->lock);
802 capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
804 pthread_mutex_unlock(&private_display->lock);
810 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
814 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
816 pthread_mutex_lock(&private_display->lock);
818 *capabilities = private_layer->caps.capabilities;
820 pthread_mutex_unlock(&private_display->lock);
826 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
830 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
831 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
833 pthread_mutex_lock(&private_display->lock);
835 *formats = (const tbm_format*)private_layer->caps.formats;
836 *count = private_layer->caps.format_count;
838 pthread_mutex_unlock(&private_display->lock);
844 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
848 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
849 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
851 pthread_mutex_lock(&private_display->lock);
853 *props = (const tdm_prop*)private_output->caps.props;
854 *count = private_output->caps.prop_count;
856 pthread_mutex_unlock(&private_display->lock);
862 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
866 TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
868 pthread_mutex_lock(&private_display->lock);
870 *zpos = private_layer->caps.zpos;
872 pthread_mutex_unlock(&private_display->lock);
878 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
880 tdm_func_display *func_display;
883 pthread_mutex_lock(&private_display->lock);
885 func_display = &private_display->func_display;
887 if (!func_display->layer_set_property)
889 pthread_mutex_unlock(&private_display->lock);
890 return TDM_ERROR_NONE;
893 ret = func_display->layer_set_property(private_layer->layer, id, value);
895 pthread_mutex_unlock(&private_display->lock);
901 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
903 tdm_func_display *func_display;
906 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
908 pthread_mutex_lock(&private_display->lock);
910 func_display = &private_display->func_display;
912 if (!func_display->layer_get_property)
914 pthread_mutex_unlock(&private_display->lock);
915 return TDM_ERROR_NONE;
918 ret = func_display->layer_get_property(private_layer->layer, id, value);
920 pthread_mutex_unlock(&private_display->lock);
926 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
928 tdm_func_display *func_display;
931 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
933 pthread_mutex_lock(&private_display->lock);
935 func_display = &private_display->func_display;
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 if (!func_display->layer_set_buffer)
989 pthread_mutex_unlock(&private_display->lock);
990 return TDM_ERROR_NONE;
994 tdm_buffer_ref_backend(buffer);
995 ret = func_display->layer_set_buffer(private_layer->layer,
996 tdm_buffer_get_surface(buffer));
997 tdm_buffer_unref_backend(buffer);
999 pthread_mutex_unlock(&private_display->lock);
1005 tdm_layer_unset_buffer(tdm_layer *layer)
1007 tdm_func_display *func_display;
1010 pthread_mutex_lock(&private_display->lock);
1012 func_display = &private_display->func_display;
1014 if (!func_display->layer_unset_buffer)
1016 pthread_mutex_unlock(&private_display->lock);
1017 return TDM_ERROR_NONE;
1020 ret = func_display->layer_unset_buffer(private_layer->layer);
1022 pthread_mutex_unlock(&private_display->lock);
1028 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1030 tdm_capture *capture = NULL;
1032 LAYER_FUNC_ENTRY_ERROR();
1034 pthread_mutex_lock(&private_display->lock);
1036 capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
1038 pthread_mutex_unlock(&private_display->lock);