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
94 #define LAYER_FUNC_ENTRY_VOID_RETURN() \
95 tdm_private_display *private_display; \
96 tdm_private_output *private_output; \
97 tdm_private_layer *private_layer; \
98 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
99 TDM_RETURN_IF_FAIL(layer != NULL); \
100 private_layer = (tdm_private_layer*)layer; \
101 private_output = private_layer->private_output; \
102 private_display = private_output->private_display
105 tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities)
107 DISPLAY_FUNC_ENTRY();
109 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
111 pthread_mutex_lock(&private_display->lock);
113 *capabilities = private_display->capabilities;
115 pthread_mutex_unlock(&private_display->lock);
121 tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities)
123 DISPLAY_FUNC_ENTRY();
125 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
127 pthread_mutex_lock(&private_display->lock);
129 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP))
131 TDM_ERR("no pp capability");
132 pthread_mutex_unlock(&private_display->lock);
133 return TDM_ERROR_NO_CAPABILITY;
136 *capabilities = private_display->caps_pp.capabilities;
138 pthread_mutex_unlock(&private_display->lock);
144 tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
146 DISPLAY_FUNC_ENTRY();
148 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
149 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
151 pthread_mutex_lock(&private_display->lock);
153 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP))
155 TDM_ERR("no pp capability");
156 pthread_mutex_unlock(&private_display->lock);
157 return TDM_ERROR_NO_CAPABILITY;
160 *formats = (const tbm_format*)private_display->caps_pp.formats;
161 *count = private_display->caps_pp.format_count;
163 pthread_mutex_unlock(&private_display->lock);
169 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
170 int *max_w, int *max_h, int *preferred_align)
172 DISPLAY_FUNC_ENTRY();
174 pthread_mutex_lock(&private_display->lock);
176 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP))
178 TDM_ERR("no pp capability");
179 pthread_mutex_unlock(&private_display->lock);
180 return TDM_ERROR_NO_CAPABILITY;
184 *min_w = private_display->caps_pp.min_w;
186 *min_h = private_display->caps_pp.min_h;
188 *max_w = private_display->caps_pp.max_w;
190 *max_h = private_display->caps_pp.max_h;
192 *preferred_align = private_display->caps_pp.preferred_align;
194 pthread_mutex_unlock(&private_display->lock);
200 tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
202 DISPLAY_FUNC_ENTRY();
204 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
206 pthread_mutex_lock(&private_display->lock);
208 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
210 TDM_ERR("no capture capability");
211 pthread_mutex_unlock(&private_display->lock);
212 return TDM_ERROR_NO_CAPABILITY;
215 *capabilities = private_display->caps_capture.capabilities;
217 pthread_mutex_unlock(&private_display->lock);
223 tdm_display_get_catpure_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
225 DISPLAY_FUNC_ENTRY();
227 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
228 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
230 pthread_mutex_lock(&private_display->lock);
232 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
234 TDM_ERR("no capture capability");
235 pthread_mutex_unlock(&private_display->lock);
236 return TDM_ERROR_NO_CAPABILITY;
239 *formats = (const tbm_format*)private_display->caps_capture.formats;
240 *count = private_display->caps_capture.format_count;
242 pthread_mutex_unlock(&private_display->lock);
248 tdm_display_get_output_count(tdm_display *dpy, int *count)
250 tdm_private_output *private_output = NULL;
252 DISPLAY_FUNC_ENTRY();
254 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
256 pthread_mutex_lock(&private_display->lock);
259 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
264 pthread_mutex_unlock(&private_display->lock);
265 return TDM_ERROR_NONE;
268 pthread_mutex_unlock(&private_display->lock);
275 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
277 tdm_private_output *private_output = NULL;
280 DISPLAY_FUNC_ENTRY_ERROR();
282 pthread_mutex_lock(&private_display->lock);
285 *error = TDM_ERROR_NONE;
288 LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
292 pthread_mutex_unlock(&private_display->lock);
293 return private_output;
298 pthread_mutex_unlock(&private_display->lock);
304 tdm_display_get_fd(tdm_display *dpy, int *fd)
306 tdm_func_display *func_display;
307 DISPLAY_FUNC_ENTRY();
309 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
311 pthread_mutex_lock(&private_display->lock);
313 func_display = &private_display->func_display;
315 if (!func_display->display_get_fd)
317 pthread_mutex_unlock(&private_display->lock);
318 return TDM_ERROR_NONE;
321 ret = func_display->display_get_fd(private_display->bdata, fd);
323 pthread_mutex_unlock(&private_display->lock);
329 tdm_display_handle_events(tdm_display *dpy)
331 tdm_func_display *func_display;
332 DISPLAY_FUNC_ENTRY();
334 pthread_mutex_lock(&private_display->lock);
336 func_display = &private_display->func_display;
338 if (!func_display->display_handle_events)
340 pthread_mutex_unlock(&private_display->lock);
341 return TDM_ERROR_NONE;
344 ret = func_display->display_handle_events(private_display->bdata);
346 pthread_mutex_unlock(&private_display->lock);
352 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
356 DISPLAY_FUNC_ENTRY_ERROR();
358 pthread_mutex_lock(&private_display->lock);
360 pp = (tdm_pp*)tdm_pp_create_internal(private_display, error);
362 pthread_mutex_unlock(&private_display->lock);
368 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
372 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
374 pthread_mutex_lock(&private_display->lock);
376 *status = private_output->caps.status;
378 pthread_mutex_unlock(&private_display->lock);
384 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
388 TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
390 pthread_mutex_lock(&private_display->lock);
392 *type = private_output->caps.type;
394 pthread_mutex_unlock(&private_display->lock);
400 tdm_output_get_layer_count(tdm_output *output, int *count)
402 tdm_private_layer *private_layer = NULL;
406 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
408 pthread_mutex_lock(&private_display->lock);
411 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
415 pthread_mutex_unlock(&private_display->lock);
416 return TDM_ERROR_NONE;
419 pthread_mutex_unlock(&private_display->lock);
426 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
428 tdm_private_layer *private_layer = NULL;
431 OUTPUT_FUNC_ENTRY_ERROR();
433 pthread_mutex_lock(&private_display->lock);
436 *error = TDM_ERROR_NONE;
438 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
442 pthread_mutex_unlock(&private_display->lock);
443 return private_layer;
448 pthread_mutex_unlock(&private_display->lock);
454 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, int *count)
458 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
459 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
461 pthread_mutex_lock(&private_display->lock);
463 *props = (const tdm_prop*)private_output->caps.props;
464 *count = private_output->caps.prop_count;
466 pthread_mutex_unlock(&private_display->lock);
472 tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes, int *count)
476 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
477 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
479 pthread_mutex_lock(&private_display->lock);
481 *modes = (const tdm_output_mode*)private_output->caps.modes;
482 *count = private_output->caps.mode_count;
484 pthread_mutex_unlock(&private_display->lock);
490 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
491 int *max_w, int *max_h, int *preferred_align)
495 pthread_mutex_lock(&private_display->lock);
498 *min_w = private_output->caps.min_w;
500 *min_h = private_output->caps.min_h;
502 *max_w = private_output->caps.max_w;
504 *max_h = private_output->caps.max_h;
506 *preferred_align = private_output->caps.preferred_align;
508 pthread_mutex_unlock(&private_display->lock);
514 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, unsigned int *mmHeight)
518 pthread_mutex_lock(&private_display->lock);
521 *mmWidth = private_output->caps.mmWidth;
523 *mmHeight = private_output->caps.mmHeight;
525 pthread_mutex_unlock(&private_display->lock);
531 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
534 TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
536 pthread_mutex_lock(&private_display->lock);
538 *subpixel = private_output->caps.subpixel;
540 pthread_mutex_unlock(&private_display->lock);
546 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
549 TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
551 pthread_mutex_lock(&private_display->lock);
553 *pipe = private_output->pipe;
555 pthread_mutex_unlock(&private_display->lock);
562 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
564 tdm_func_display *func_display;
567 pthread_mutex_lock(&private_display->lock);
569 func_display = &private_display->func_display;
571 if (!func_display->output_set_property)
573 pthread_mutex_unlock(&private_display->lock);
574 return TDM_ERROR_NONE;
577 ret = func_display->output_set_property(private_output->output_backend, id, value);
579 pthread_mutex_unlock(&private_display->lock);
585 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
587 tdm_func_display *func_display;
590 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
592 pthread_mutex_lock(&private_display->lock);
594 func_display = &private_display->func_display;
596 if (!func_display->output_get_property)
598 pthread_mutex_unlock(&private_display->lock);
599 return TDM_ERROR_NONE;
602 ret = func_display->output_get_property(private_output->output_backend, id, value);
604 pthread_mutex_unlock(&private_display->lock);
610 _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
611 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
613 tdm_private_vblank_handler *vblank_handler = user_data;
614 tdm_private_display *private_display;
616 TDM_RETURN_IF_FAIL(vblank_handler);
618 private_display = vblank_handler->private_output->private_display;
620 if (vblank_handler->func)
622 pthread_mutex_unlock(&private_display->lock);
623 vblank_handler->func(vblank_handler->private_output, sequence,
624 tv_sec, tv_usec, vblank_handler->user_data);
625 pthread_mutex_lock(&private_display->lock);
628 LIST_DEL(&vblank_handler->link);
629 free(vblank_handler);
633 _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
634 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
636 tdm_private_commit_handler *commit_handler = user_data;
637 tdm_private_display *private_display;
638 tdm_private_output *private_output;
639 tdm_private_layer *private_layer = NULL;
641 TDM_RETURN_IF_FAIL(commit_handler);
643 private_output = commit_handler->private_output;
644 private_display = private_output->private_display;
646 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
648 if (!private_layer->waiting_buffer)
651 if (private_layer->showing_buffer)
653 pthread_mutex_unlock(&private_display->lock);
654 tdm_buffer_unref_backend(private_layer->showing_buffer);
655 pthread_mutex_lock(&private_display->lock);
657 if (private_layer->buffer_queue)
659 pthread_mutex_unlock(&private_display->lock);
660 tbm_surface_queue_release(private_layer->buffer_queue,
661 private_layer->showing_buffer);
662 pthread_mutex_lock(&private_display->lock);
666 private_layer->showing_buffer = private_layer->waiting_buffer;
667 private_layer->waiting_buffer = NULL;
670 if (commit_handler->func)
672 pthread_mutex_unlock(&private_display->lock);
673 commit_handler->func(private_output, sequence,
674 tv_sec, tv_usec, commit_handler->user_data);
675 pthread_mutex_lock(&private_display->lock);
678 LIST_DEL(&commit_handler->link);
679 free(commit_handler);
683 tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
684 tdm_output_vblank_handler func, void *user_data)
686 tdm_func_display *func_display;
687 tdm_private_vblank_handler *vblank_handler;
690 pthread_mutex_lock(&private_display->lock);
692 func_display = &private_display->func_display;
694 if (!func_display->output_wait_vblank)
696 pthread_mutex_unlock(&private_display->lock);
697 return TDM_ERROR_NONE;
700 vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
703 TDM_ERR("failed: alloc memory");
704 pthread_mutex_unlock(&private_display->lock);
705 return TDM_ERROR_OUT_OF_MEMORY;
708 LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
709 vblank_handler->private_output = private_output;
710 vblank_handler->func = func;
711 vblank_handler->user_data = user_data;
713 ret = func_display->output_wait_vblank(private_output->output_backend, interval,
714 sync, vblank_handler);
715 if (ret != TDM_ERROR_NONE)
717 pthread_mutex_unlock(&private_display->lock);
721 if (!private_output->regist_vblank_cb)
723 private_output->regist_vblank_cb = 1;
724 ret = func_display->output_set_vblank_handler(private_output->output_backend,
725 _tdm_output_cb_vblank);
728 pthread_mutex_unlock(&private_display->lock);
734 _tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
736 tdm_func_display *func_display;
737 tdm_private_commit_handler *commit_handler;
740 func_display = &private_display->func_display;
742 if (!func_display->output_commit)
744 return TDM_ERROR_NONE;
747 commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
750 TDM_ERR("failed: alloc memory");
751 return TDM_ERROR_OUT_OF_MEMORY;
754 LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
755 commit_handler->private_output = private_output;
756 commit_handler->func = func;
757 commit_handler->user_data = user_data;
759 ret = func_display->output_commit(private_output->output_backend, sync, commit_handler);
760 if (ret != TDM_ERROR_NONE)
765 if (!private_output->regist_commit_cb)
767 private_output->regist_commit_cb = 1;
768 ret = func_display->output_set_commit_handler(private_output->output_backend,
769 _tdm_output_cb_commit);
776 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
780 pthread_mutex_lock(&private_display->lock);
782 ret = _tdm_output_commit(output, sync, func, user_data);
784 pthread_mutex_unlock(&private_display->lock);
790 tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
792 tdm_func_display *func_display;
795 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
797 pthread_mutex_lock(&private_display->lock);
799 func_display = &private_display->func_display;
801 if (!func_display->output_set_mode)
803 pthread_mutex_unlock(&private_display->lock);
804 return TDM_ERROR_NONE;
807 ret = func_display->output_set_mode(private_output->output_backend, mode);
809 pthread_mutex_unlock(&private_display->lock);
815 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
817 tdm_func_display *func_display;
820 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
822 pthread_mutex_lock(&private_display->lock);
824 func_display = &private_display->func_display;
826 if (!func_display->output_get_mode)
828 pthread_mutex_unlock(&private_display->lock);
829 return TDM_ERROR_NONE;
832 ret = func_display->output_get_mode(private_output->output_backend, mode);
834 pthread_mutex_unlock(&private_display->lock);
840 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
842 tdm_func_display *func_display;
845 if (dpms_value < TDM_OUTPUT_DPMS_ON)
846 dpms_value = TDM_OUTPUT_DPMS_ON;
847 else if (dpms_value > TDM_OUTPUT_DPMS_OFF)
848 dpms_value = TDM_OUTPUT_DPMS_OFF;
850 pthread_mutex_lock(&private_display->lock);
852 func_display = &private_display->func_display;
854 if (!func_display->output_set_dpms)
856 pthread_mutex_unlock(&private_display->lock);
857 return TDM_ERROR_NONE;
860 ret = func_display->output_set_dpms(private_output->output_backend, dpms_value);
862 pthread_mutex_unlock(&private_display->lock);
868 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
870 tdm_func_display *func_display;
873 TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
875 pthread_mutex_lock(&private_display->lock);
877 func_display = &private_display->func_display;
879 if (!func_display->output_get_dpms)
881 pthread_mutex_unlock(&private_display->lock);
882 return TDM_ERROR_NONE;
885 ret = func_display->output_get_dpms(private_output->output_backend, dpms_value);
887 pthread_mutex_unlock(&private_display->lock);
893 tdm_output_create_capture(tdm_output *output, tdm_error *error)
895 tdm_capture *capture = NULL;
897 OUTPUT_FUNC_ENTRY_ERROR();
899 pthread_mutex_lock(&private_display->lock);
901 capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
903 pthread_mutex_unlock(&private_display->lock);
909 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
913 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
915 pthread_mutex_lock(&private_display->lock);
917 *capabilities = private_layer->caps.capabilities;
919 pthread_mutex_unlock(&private_display->lock);
925 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
929 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
930 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
932 pthread_mutex_lock(&private_display->lock);
934 *formats = (const tbm_format*)private_layer->caps.formats;
935 *count = private_layer->caps.format_count;
937 pthread_mutex_unlock(&private_display->lock);
943 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
947 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
948 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
950 pthread_mutex_lock(&private_display->lock);
952 *props = (const tdm_prop*)private_layer->caps.props;
953 *count = private_layer->caps.prop_count;
955 pthread_mutex_unlock(&private_display->lock);
961 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
965 TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
967 pthread_mutex_lock(&private_display->lock);
969 *zpos = private_layer->caps.zpos;
971 pthread_mutex_unlock(&private_display->lock);
977 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
979 tdm_func_display *func_display;
982 pthread_mutex_lock(&private_display->lock);
984 func_display = &private_display->func_display;
986 if (!func_display->layer_set_property)
988 pthread_mutex_unlock(&private_display->lock);
989 return TDM_ERROR_NONE;
992 ret = func_display->layer_set_property(private_layer->layer_backend, id, value);
994 pthread_mutex_unlock(&private_display->lock);
1000 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
1002 tdm_func_display *func_display;
1005 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
1007 pthread_mutex_lock(&private_display->lock);
1009 func_display = &private_display->func_display;
1011 if (!func_display->layer_get_property)
1013 pthread_mutex_unlock(&private_display->lock);
1014 return TDM_ERROR_NONE;
1017 ret = func_display->layer_get_property(private_layer->layer_backend, id, value);
1019 pthread_mutex_unlock(&private_display->lock);
1025 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
1027 tdm_func_display *func_display;
1030 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1032 pthread_mutex_lock(&private_display->lock);
1034 func_display = &private_display->func_display;
1036 private_layer->usable = 0;
1038 if (!func_display->layer_set_info)
1040 pthread_mutex_unlock(&private_display->lock);
1041 return TDM_ERROR_NONE;
1044 ret = func_display->layer_set_info(private_layer->layer_backend, info);
1046 pthread_mutex_unlock(&private_display->lock);
1052 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
1054 tdm_func_display *func_display;
1057 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
1059 pthread_mutex_lock(&private_display->lock);
1061 func_display = &private_display->func_display;
1063 if (!func_display->layer_get_info)
1065 pthread_mutex_unlock(&private_display->lock);
1066 return TDM_ERROR_NONE;
1069 ret = func_display->layer_get_info(private_layer->layer_backend, info);
1071 pthread_mutex_unlock(&private_display->lock);
1077 tdm_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
1079 tdm_func_display *func_display;
1082 TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
1084 pthread_mutex_lock(&private_display->lock);
1086 func_display = &private_display->func_display;
1088 private_layer->usable = 0;
1090 if (!func_display->layer_set_buffer)
1092 pthread_mutex_unlock(&private_display->lock);
1093 return TDM_ERROR_NONE;
1096 if (private_layer->waiting_buffer)
1098 pthread_mutex_unlock(&private_display->lock);
1099 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1100 pthread_mutex_lock(&private_display->lock);
1103 private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
1105 ret = func_display->layer_set_buffer(private_layer->layer_backend, buffer);
1107 pthread_mutex_unlock(&private_display->lock);
1113 tdm_layer_unset_buffer(tdm_layer *layer)
1115 tdm_func_display *func_display;
1118 pthread_mutex_lock(&private_display->lock);
1120 func_display = &private_display->func_display;
1122 if (private_layer->waiting_buffer)
1124 pthread_mutex_unlock(&private_display->lock);
1125 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1126 pthread_mutex_lock(&private_display->lock);
1127 private_layer->waiting_buffer = NULL;
1130 if (private_layer->showing_buffer)
1132 pthread_mutex_unlock(&private_display->lock);
1133 tdm_buffer_unref_backend(private_layer->showing_buffer);
1134 pthread_mutex_lock(&private_display->lock);
1135 private_layer->showing_buffer = NULL;
1138 private_layer->usable = 1;
1140 if (!func_display->layer_unset_buffer)
1142 pthread_mutex_unlock(&private_display->lock);
1143 return TDM_ERROR_NONE;
1146 ret = func_display->layer_unset_buffer(private_layer->layer_backend);
1148 pthread_mutex_unlock(&private_display->lock);
1154 _tbm_layer_queue_acquirable_cb(tbm_surface_queue_h surface_queue, void *data)
1156 TDM_RETURN_IF_FAIL(data != NULL);
1157 tdm_layer *layer = data;
1158 tdm_func_display *func_display;
1159 tbm_surface_h surface = NULL;
1160 LAYER_FUNC_ENTRY_VOID_RETURN();
1162 pthread_mutex_lock(&private_display->lock);
1164 func_display = &private_display->func_display;
1165 if (!func_display->layer_set_buffer)
1167 pthread_mutex_unlock(&private_display->lock);
1171 if (TBM_SURFACE_QUEUE_ERROR_NONE != tbm_surface_queue_acquire(private_layer->buffer_queue, &surface) ||
1174 TDM_ERR("tbm_surface_queue_acquire() failed surface:%p", surface);
1175 pthread_mutex_unlock(&private_display->lock);
1179 if (private_layer->waiting_buffer)
1181 pthread_mutex_unlock(&private_display->lock);
1182 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1183 tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer);
1184 pthread_mutex_lock(&private_display->lock);
1187 private_layer->waiting_buffer = tdm_buffer_ref_backend(surface);
1189 func_display->layer_set_buffer(private_layer->layer_backend, surface);
1191 ret = _tdm_output_commit(private_layer->private_output, 0, NULL, NULL);
1192 if (ret != TDM_ERROR_NONE)
1193 TDM_ERR("_tdm_output_commit() is fail");
1195 pthread_mutex_unlock(&private_display->lock);
1199 _tbm_layer_queue_destroy_cb(tbm_surface_queue_h surface_queue, void *data)
1201 TDM_RETURN_IF_FAIL(data != NULL);
1202 tdm_layer *layer = data;
1203 LAYER_FUNC_ENTRY_VOID_RETURN();
1204 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1206 pthread_mutex_lock(&private_display->lock);
1208 if (private_layer->waiting_buffer)
1210 pthread_mutex_unlock(&private_display->lock);
1211 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1212 tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer);
1213 pthread_mutex_lock(&private_display->lock);
1216 private_layer->buffer_queue = NULL;
1218 pthread_mutex_unlock(&private_display->lock);
1222 tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue)
1224 tdm_func_display *func_display;
1227 TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER);
1229 pthread_mutex_lock(&private_display->lock);
1231 func_display = &private_display->func_display;
1233 private_layer->usable = 0;
1235 if (!func_display->layer_set_buffer)
1237 pthread_mutex_unlock(&private_display->lock);
1238 return TDM_ERROR_NONE;
1241 if (buffer_queue == private_layer->buffer_queue)
1243 pthread_mutex_unlock(&private_display->lock);
1244 return TDM_ERROR_NONE;
1247 if (private_layer->waiting_buffer)
1249 pthread_mutex_unlock(&private_display->lock);
1250 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1251 tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer);
1252 private_layer->waiting_buffer = NULL;
1253 pthread_mutex_lock(&private_display->lock);
1256 private_layer->buffer_queue = buffer_queue;
1257 tbm_surface_queue_set_acquirable_cb(private_layer->buffer_queue,
1258 _tbm_layer_queue_acquirable_cb,
1260 tbm_surface_queue_set_destroy_cb(private_layer->buffer_queue,
1261 _tbm_layer_queue_destroy_cb,
1263 pthread_mutex_unlock(&private_display->lock);
1269 tdm_layer_unset_buffer_queue(tdm_layer *layer)
1271 tdm_func_display *func_display;
1274 pthread_mutex_lock(&private_display->lock);
1276 func_display = &private_display->func_display;
1278 if (private_layer->waiting_buffer)
1280 pthread_mutex_unlock(&private_display->lock);
1281 tdm_buffer_unref_backend(private_layer->waiting_buffer);
1282 tbm_surface_queue_release(private_layer->buffer_queue, private_layer->waiting_buffer);
1283 private_layer->waiting_buffer = NULL;
1284 pthread_mutex_lock(&private_display->lock);
1287 if (private_layer->showing_buffer)
1289 pthread_mutex_unlock(&private_display->lock);
1290 tdm_buffer_unref_backend(private_layer->showing_buffer);
1291 tbm_surface_queue_release(private_layer->buffer_queue, private_layer->showing_buffer);
1292 pthread_mutex_lock(&private_display->lock);
1293 private_layer->showing_buffer = NULL;
1296 tbm_surface_queue_set_acquirable_cb(private_layer->buffer_queue, NULL, NULL);
1297 tbm_surface_queue_set_destroy_cb(private_layer->buffer_queue, NULL, NULL);
1298 private_layer->buffer_queue = NULL;
1299 private_layer->usable = 1;
1301 if (!func_display->layer_unset_buffer)
1303 pthread_mutex_unlock(&private_display->lock);
1304 return TDM_ERROR_NONE;
1307 ret = func_display->layer_unset_buffer(private_layer->layer_backend);
1309 pthread_mutex_unlock(&private_display->lock);
1315 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1319 TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1321 pthread_mutex_lock(&private_display->lock);
1323 *usable = private_layer->usable;
1325 pthread_mutex_unlock(&private_display->lock);
1331 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1333 tdm_func_display *func_display;
1336 pthread_mutex_lock(&private_display->lock);
1338 func_display = &private_display->func_display;
1340 if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
1342 TDM_ERR("layer is not video layer");
1343 pthread_mutex_unlock(&private_display->lock);
1344 return TDM_ERROR_INVALID_PARAMETER;
1347 if (!func_display->layer_set_video_pos)
1349 pthread_mutex_unlock(&private_display->lock);
1350 return TDM_ERROR_NONE;
1353 ret = func_display->layer_set_video_pos(private_layer->layer_backend, zpos);
1355 pthread_mutex_unlock(&private_display->lock);
1361 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1363 tdm_capture *capture = NULL;
1365 LAYER_FUNC_ENTRY_ERROR();
1367 pthread_mutex_lock(&private_display->lock);
1369 capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
1371 pthread_mutex_unlock(&private_display->lock);