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;
567 tdm_private_display *private_display;
568 tdm_private_display *private_display_backend;
569 tdm_private_vblank_handler *vblank_handler = user_data;
570 TDM_RETURN_IF_FAIL(vblank_handler);
572 private_output = vblank_handler->private_output;
573 TDM_RETURN_IF_FAIL(private_output);
575 private_display = private_output->private_display;
576 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
578 if (private_output->output == output)
579 private_display_backend = private_output->private_display;
582 pthread_mutex_unlock(&private_display_backend->lock);
584 if (vblank_handler->func)
585 vblank_handler->func(vblank_handler->private_output, sequence, tv_sec, tv_usec, vblank_handler->user_data);
587 pthread_mutex_lock(&private_display_backend->lock);
589 LIST_DEL(&vblank_handler->link);
590 free(vblank_handler);
594 _tdm_output_cb_commit(tdm_output *output, unsigned int sequence,
595 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
597 tdm_private_output *private_output;
598 tdm_private_display *private_display;
599 tdm_private_display *private_display_backend;
600 tdm_private_commit_handler *commit_handler = user_data;
601 TDM_RETURN_IF_FAIL(commit_handler);
603 private_output = commit_handler->private_output;
604 TDM_RETURN_IF_FAIL(private_output);
606 private_display = private_output->private_display;
607 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
609 if (private_output->output == output)
610 private_display_backend = private_output->private_display;
613 pthread_mutex_unlock(&private_display_backend->lock);
615 if (commit_handler->func)
616 commit_handler->func(commit_handler->private_output, sequence, tv_sec, tv_usec, commit_handler->user_data);
618 pthread_mutex_lock(&private_display_backend->lock);
620 LIST_DEL(&commit_handler->link);
621 free(commit_handler);
625 tdm_output_wait_vblank(tdm_output *output, int interval, int sync, tdm_output_vblank_handler func, void *user_data)
627 tdm_func_display *func_display;
628 tdm_private_vblank_handler *vblank_handler;
631 pthread_mutex_lock(&private_display->lock);
633 func_display = &private_display->func_display;
635 if (!func_display->output_wait_vblank)
637 pthread_mutex_unlock(&private_display->lock);
638 return TDM_ERROR_NONE;
641 vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
644 TDM_ERR("failed: alloc memory");
645 pthread_mutex_unlock(&private_display->lock);
646 return TDM_ERROR_OUT_OF_MEMORY;
649 LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
650 vblank_handler->private_output = private_output;
651 vblank_handler->func = func;
652 vblank_handler->user_data = user_data;
654 ret = func_display->output_wait_vblank(private_output->output, interval, sync, vblank_handler);
655 if (ret != TDM_ERROR_NONE)
657 pthread_mutex_unlock(&private_display->lock);
661 if (!private_output->regist_vblank_cb)
663 private_output->regist_vblank_cb = 1;
664 ret = func_display->output_set_vblank_handler(private_output->output, _tdm_output_cb_vblank);
667 pthread_mutex_unlock(&private_display->lock);
673 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
675 tdm_func_display *func_display;
676 tdm_private_commit_handler *commit_handler;
679 pthread_mutex_lock(&private_display->lock);
681 func_display = &private_display->func_display;
683 if (!func_display->output_commit)
685 pthread_mutex_unlock(&private_display->lock);
686 return TDM_ERROR_NONE;
689 commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
692 TDM_ERR("failed: alloc memory");
693 pthread_mutex_unlock(&private_display->lock);
694 return TDM_ERROR_OUT_OF_MEMORY;
697 LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
698 commit_handler->private_output = private_output;
699 commit_handler->func = func;
700 commit_handler->user_data = user_data;
702 ret = func_display->output_commit(private_output->output, sync, commit_handler);
703 if (ret != TDM_ERROR_NONE)
705 pthread_mutex_unlock(&private_display->lock);
709 if (!private_output->regist_commit_cb)
711 private_output->regist_commit_cb = 1;
712 ret = func_display->output_set_commit_handler(private_output->output, _tdm_output_cb_commit);
715 pthread_mutex_unlock(&private_display->lock);
721 tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
723 tdm_func_display *func_display;
726 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
728 pthread_mutex_lock(&private_display->lock);
730 func_display = &private_display->func_display;
732 if (!func_display->output_set_mode)
734 pthread_mutex_unlock(&private_display->lock);
735 return TDM_ERROR_NONE;
738 ret = func_display->output_set_mode(private_output->output, mode);
740 pthread_mutex_unlock(&private_display->lock);
746 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
748 tdm_func_display *func_display;
751 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
753 pthread_mutex_lock(&private_display->lock);
755 func_display = &private_display->func_display;
757 if (!func_display->output_get_mode)
759 pthread_mutex_unlock(&private_display->lock);
760 return TDM_ERROR_NONE;
763 ret = func_display->output_get_mode(private_output->output, mode);
765 pthread_mutex_unlock(&private_display->lock);
771 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
773 tdm_func_display *func_display;
776 TDM_RETURN_VAL_IF_FAIL(dpms_value >= TDM_OUTPUT_DPMS_ON, TDM_ERROR_INVALID_PARAMETER);
777 TDM_RETURN_VAL_IF_FAIL(dpms_value < TDM_OUTPUT_DPMS_MAX, TDM_ERROR_INVALID_PARAMETER);
779 pthread_mutex_lock(&private_display->lock);
781 func_display = &private_display->func_display;
783 if (!func_display->output_set_dpms)
785 pthread_mutex_unlock(&private_display->lock);
786 return TDM_ERROR_NONE;
789 ret = func_display->output_set_dpms(private_output->output, dpms_value);
791 pthread_mutex_unlock(&private_display->lock);
797 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
799 tdm_func_display *func_display;
802 TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
804 pthread_mutex_lock(&private_display->lock);
806 func_display = &private_display->func_display;
808 if (!func_display->output_get_dpms)
810 pthread_mutex_unlock(&private_display->lock);
811 return TDM_ERROR_NONE;
814 ret = func_display->output_get_dpms(private_output->output, dpms_value);
816 pthread_mutex_unlock(&private_display->lock);
822 tdm_output_create_capture(tdm_output *output, tdm_error *error)
824 tdm_capture *capture = NULL;
826 OUTPUT_FUNC_ENTRY_ERROR();
828 pthread_mutex_lock(&private_display->lock);
830 capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
832 pthread_mutex_unlock(&private_display->lock);
838 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
842 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
844 pthread_mutex_lock(&private_display->lock);
846 *capabilities = private_layer->caps.capabilities;
848 pthread_mutex_unlock(&private_display->lock);
854 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
858 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
859 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
861 pthread_mutex_lock(&private_display->lock);
863 *formats = (const tbm_format*)private_layer->caps.formats;
864 *count = private_layer->caps.format_count;
866 pthread_mutex_unlock(&private_display->lock);
872 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
876 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
877 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
879 pthread_mutex_lock(&private_display->lock);
881 *props = (const tdm_prop*)private_layer->caps.props;
882 *count = private_layer->caps.prop_count;
884 pthread_mutex_unlock(&private_display->lock);
890 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
894 TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
896 pthread_mutex_lock(&private_display->lock);
898 *zpos = private_layer->caps.zpos;
900 pthread_mutex_unlock(&private_display->lock);
906 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
908 tdm_func_display *func_display;
911 pthread_mutex_lock(&private_display->lock);
913 func_display = &private_display->func_display;
915 if (!func_display->layer_set_property)
917 pthread_mutex_unlock(&private_display->lock);
918 return TDM_ERROR_NONE;
921 ret = func_display->layer_set_property(private_layer->layer, id, value);
923 pthread_mutex_unlock(&private_display->lock);
929 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
931 tdm_func_display *func_display;
934 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
936 pthread_mutex_lock(&private_display->lock);
938 func_display = &private_display->func_display;
940 if (!func_display->layer_get_property)
942 pthread_mutex_unlock(&private_display->lock);
943 return TDM_ERROR_NONE;
946 ret = func_display->layer_get_property(private_layer->layer, id, value);
948 pthread_mutex_unlock(&private_display->lock);
954 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
956 tdm_func_display *func_display;
959 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
961 pthread_mutex_lock(&private_display->lock);
963 func_display = &private_display->func_display;
965 private_layer->usable = 0;
967 if (!func_display->layer_set_info)
969 pthread_mutex_unlock(&private_display->lock);
970 return TDM_ERROR_NONE;
973 ret = func_display->layer_set_info(private_layer->layer, info);
975 pthread_mutex_unlock(&private_display->lock);
981 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
983 tdm_func_display *func_display;
986 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
988 pthread_mutex_lock(&private_display->lock);
990 func_display = &private_display->func_display;
992 if (!func_display->layer_get_info)
994 pthread_mutex_unlock(&private_display->lock);
995 return TDM_ERROR_NONE;
998 ret = func_display->layer_get_info(private_layer->layer, info);
1000 pthread_mutex_unlock(&private_display->lock);
1006 tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
1008 tdm_func_display *func_display;
1011 TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
1013 pthread_mutex_lock(&private_display->lock);
1015 func_display = &private_display->func_display;
1017 private_layer->usable = 0;
1019 if (!func_display->layer_set_buffer)
1021 pthread_mutex_unlock(&private_display->lock);
1022 return TDM_ERROR_NONE;
1025 if (private_layer->current_buffer)
1027 /* TODO: need to unref after next buffer is showing on screen */
1028 tdm_buffer_unref_backend(private_layer->current_buffer);
1029 tdm_buffer_unref(private_layer->current_buffer);
1032 private_layer->current_buffer = tdm_buffer_ref(buffer, NULL);
1033 tdm_buffer_ref_backend(buffer);
1035 ret = func_display->layer_set_buffer(private_layer->layer,
1036 tdm_buffer_get_surface(buffer));
1038 pthread_mutex_unlock(&private_display->lock);
1044 tdm_layer_unset_buffer(tdm_layer *layer)
1046 tdm_func_display *func_display;
1049 pthread_mutex_lock(&private_display->lock);
1051 func_display = &private_display->func_display;
1053 if (private_layer->current_buffer)
1055 tdm_buffer_unref(private_layer->current_buffer);
1056 tdm_buffer_unref_backend(private_layer->current_buffer);
1057 private_layer->current_buffer = NULL;
1060 private_layer->usable = 1;
1062 if (!func_display->layer_unset_buffer)
1064 pthread_mutex_unlock(&private_display->lock);
1065 return TDM_ERROR_NONE;
1068 ret = func_display->layer_unset_buffer(private_layer->layer);
1070 pthread_mutex_unlock(&private_display->lock);
1076 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1080 TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1082 pthread_mutex_lock(&private_display->lock);
1084 *usable = private_layer->usable;
1086 pthread_mutex_unlock(&private_display->lock);
1093 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1095 tdm_capture *capture = NULL;
1097 LAYER_FUNC_ENTRY_ERROR();
1099 pthread_mutex_lock(&private_display->lock);
1101 capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
1103 pthread_mutex_unlock(&private_display->lock);