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"
44 #define CAPTURE_FUNC_ENTRY() \
45 tdm_func_capture *func_capture; \
46 tdm_private_display *private_display; \
47 tdm_private_capture *private_capture; \
48 tdm_error ret = TDM_ERROR_NONE; \
49 TDM_RETURN_VAL_IF_FAIL(capture != NULL, TDM_ERROR_INVALID_PARAMETER); \
50 private_capture = (tdm_private_capture*)capture; \
51 private_display = private_capture->private_display; \
52 func_capture = private_capture->func_capture
55 _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer, void *user_data)
57 tdm_private_capture *private_capture = user_data;
58 tdm_private_display *private_display = private_capture->private_display;
59 int lock_after_cb_done = 0;
62 ret = pthread_mutex_trylock(&private_display->lock);
64 pthread_mutex_unlock(&private_display->lock);
65 else if (ret == EBUSY)
67 pthread_mutex_unlock(&private_display->lock);
68 lock_after_cb_done = 1;
71 tdm_buffer_unref_backend(buffer);
73 if (lock_after_cb_done)
74 pthread_mutex_lock(&private_display->lock);
77 INTERN tdm_private_capture*
78 tdm_capture_create_output_internal(tdm_private_output *private_output, tdm_error *error)
80 tdm_private_display *private_display;
81 tdm_func_display *func_display;
82 tdm_func_capture *func_capture;
83 tdm_private_capture *private_capture = NULL;
84 tdm_capture *capture_backend = NULL;
85 tdm_error ret = TDM_ERROR_NONE;
87 private_display = private_output->private_display;
88 func_display = &private_display->func_display;
89 func_capture = &private_display->func_capture;
91 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
93 TDM_ERR("no capture capability");
95 *error = TDM_ERROR_NO_CAPABILITY;
99 capture_backend = func_display->output_create_capture(private_output->output_backend, &ret);
100 if (ret != TDM_ERROR_NONE)
107 private_capture = calloc(1, sizeof(tdm_private_capture));
108 if (!private_capture)
110 TDM_ERR("failed: alloc memory");
111 func_capture->capture_destroy(capture_backend);
113 *error = TDM_ERROR_OUT_OF_MEMORY;
117 ret = func_capture->capture_set_done_handler(capture_backend, _tdm_caputre_cb_done, private_capture);
118 if (ret != TDM_ERROR_NONE)
120 TDM_ERR("set capture_done_handler failed");
121 func_capture->capture_destroy(capture_backend);
127 LIST_ADD(&private_capture->link, &private_output->capture_list);
128 private_capture->func_capture = func_capture;
129 private_capture->target = TDM_CAPTURE_TARGET_OUTPUT;
130 private_capture->private_display = private_display;
131 private_capture->private_output = private_output;
132 private_capture->private_layer = NULL;
133 private_capture->capture_backend = capture_backend;
136 *error = TDM_ERROR_NONE;
138 return private_capture;
141 INTERN tdm_private_capture*
142 tdm_capture_create_layer_internal(tdm_private_layer *private_layer, tdm_error *error)
144 tdm_private_display *private_display;
145 tdm_private_output *private_output;
146 tdm_func_display *func_display;
147 tdm_func_capture *func_capture;
148 tdm_private_capture *private_capture = NULL;
149 tdm_capture *capture_backend = NULL;
150 tdm_error ret = TDM_ERROR_NONE;
152 private_output = private_layer->private_output;
153 private_display = private_output->private_display;
154 func_display = &private_display->func_display;
155 func_capture = &private_display->func_capture;
157 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
159 TDM_ERR("no capture capability");
161 *error = TDM_ERROR_NO_CAPABILITY;
165 capture_backend = func_display->layer_create_capture(private_layer->layer_backend, &ret);
166 if (ret != TDM_ERROR_NONE)
169 private_capture = calloc(1, sizeof(tdm_private_capture));
170 if (!private_capture)
172 TDM_ERR("failed: alloc memory");
173 func_capture->capture_destroy(capture_backend);
175 *error = TDM_ERROR_OUT_OF_MEMORY;
179 LIST_ADD(&private_capture->link, &private_output->capture_list);
180 private_capture->target = TDM_CAPTURE_TARGET_LAYER;
181 private_capture->func_capture = func_capture;
182 private_capture->private_display = private_display;
183 private_capture->private_output = private_output;
184 private_capture->private_layer = private_layer;
185 private_capture->capture_backend = capture_backend;
188 *error = TDM_ERROR_NONE;
190 return private_capture;
194 tdm_capture_destroy_internal(tdm_private_capture *private_capture)
196 tdm_func_capture *func_capture;
198 if (!private_capture)
201 LIST_DEL(&private_capture->link);
203 func_capture = private_capture->func_capture;
204 func_capture->capture_destroy(private_capture->capture_backend);
206 free(private_capture);
210 tdm_capture_destroy(tdm_capture *capture)
212 tdm_private_capture *private_capture = capture;
213 tdm_private_display *private_display;
215 if (!private_capture)
218 private_display = private_capture->private_display;
220 pthread_mutex_lock(&private_display->lock);
221 tdm_capture_destroy_internal(private_capture);
222 pthread_mutex_unlock(&private_display->lock);
226 tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info)
228 CAPTURE_FUNC_ENTRY();
230 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
232 pthread_mutex_lock(&private_display->lock);
234 if (!func_capture->capture_set_info)
236 pthread_mutex_unlock(&private_display->lock);
237 return TDM_ERROR_NONE;
240 ret = func_capture->capture_set_info(private_capture->capture_backend, info);
242 pthread_mutex_unlock(&private_display->lock);
248 tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
250 CAPTURE_FUNC_ENTRY();
252 TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
254 pthread_mutex_lock(&private_display->lock);
256 if (!func_capture->capture_attach)
258 pthread_mutex_unlock(&private_display->lock);
259 return TDM_ERROR_NONE;
262 tdm_buffer_ref_backend(buffer);
263 ret = func_capture->capture_attach(private_capture->capture_backend, buffer);
265 pthread_mutex_unlock(&private_display->lock);
271 tdm_capture_commit(tdm_capture *capture)
273 CAPTURE_FUNC_ENTRY();
275 pthread_mutex_lock(&private_display->lock);
277 if (!func_capture->capture_commit)
279 pthread_mutex_unlock(&private_display->lock);
280 return TDM_ERROR_NONE;
283 ret = func_capture->capture_commit(private_capture->capture_backend);
285 pthread_mutex_unlock(&private_display->lock);