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_display->func_capture
55 _tdm_caputre_cb_done(tdm_capture *capture_backend, tbm_surface_h buffer,
58 tdm_private_capture *private_capture = user_data;
59 tdm_private_display *private_display = private_capture->private_display;
60 int lock_after_cb_done = 0;
63 ret = pthread_mutex_trylock(&private_display->lock);
65 pthread_mutex_unlock(&private_display->lock);
66 else if (ret == EBUSY) {
67 pthread_mutex_unlock(&private_display->lock);
68 lock_after_cb_done = 1;
72 TDM_INFO("done: %p", buffer);
74 tdm_buffer_remove_list(&private_capture->buffer_list, buffer);
76 tdm_buffer_unref_backend(buffer);
78 if (lock_after_cb_done)
79 pthread_mutex_lock(&private_display->lock);
82 INTERN tdm_private_capture *
83 tdm_capture_create_output_internal(tdm_private_output *private_output,
86 tdm_private_display *private_display = private_output->private_display;
87 tdm_func_output *func_output = &private_display->func_output;
88 tdm_func_capture *func_capture = &private_display->func_capture;
89 tdm_private_capture *private_capture = NULL;
90 tdm_capture *capture_backend = NULL;
91 tdm_error ret = TDM_ERROR_NONE;
93 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
94 TDM_ERR("no capture capability");
96 *error = TDM_ERROR_NO_CAPABILITY;
100 capture_backend = func_output->output_create_capture(
101 private_output->output_backend, &ret);
102 if (ret != TDM_ERROR_NONE) {
108 private_capture = calloc(1, sizeof(tdm_private_capture));
109 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,
118 _tdm_caputre_cb_done, private_capture);
119 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->target = TDM_CAPTURE_TARGET_OUTPUT;
129 private_capture->private_display = private_display;
130 private_capture->private_output = private_output;
131 private_capture->private_layer = NULL;
132 private_capture->capture_backend = capture_backend;
134 LIST_INITHEAD(&private_capture->buffer_list);
137 *error = TDM_ERROR_NONE;
139 return private_capture;
142 INTERN tdm_private_capture *
143 tdm_capture_create_layer_internal(tdm_private_layer *private_layer,
146 tdm_private_output *private_output = private_layer->private_output;
147 tdm_private_display *private_display = private_output->private_display;
148 tdm_func_layer *func_layer = &private_display->func_layer;
149 tdm_func_capture *func_capture = &private_display->func_capture;
150 tdm_private_capture *private_capture = NULL;
151 tdm_capture *capture_backend = NULL;
152 tdm_error ret = TDM_ERROR_NONE;
154 if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
155 TDM_ERR("no capture capability");
157 *error = TDM_ERROR_NO_CAPABILITY;
161 capture_backend = func_layer->layer_create_capture(private_layer->layer_backend,
163 if (ret != TDM_ERROR_NONE)
166 private_capture = calloc(1, sizeof(tdm_private_capture));
167 if (!private_capture) {
168 TDM_ERR("failed: alloc memory");
169 func_capture->capture_destroy(capture_backend);
171 *error = TDM_ERROR_OUT_OF_MEMORY;
175 LIST_ADD(&private_capture->link, &private_output->capture_list);
176 private_capture->target = TDM_CAPTURE_TARGET_LAYER;
177 private_capture->private_display = private_display;
178 private_capture->private_output = private_output;
179 private_capture->private_layer = private_layer;
180 private_capture->capture_backend = capture_backend;
182 LIST_INITHEAD(&private_capture->buffer_list);
185 *error = TDM_ERROR_NONE;
187 return private_capture;
191 tdm_capture_destroy_internal(tdm_private_capture *private_capture)
193 tdm_func_capture *func_capture;
195 if (!private_capture)
198 LIST_DEL(&private_capture->link);
200 func_capture = &private_capture->private_display->func_capture;
201 func_capture->capture_destroy(private_capture->capture_backend);
203 if (!LIST_IS_EMPTY(&private_capture->buffer_list)) {
204 char str[256] = {0,};
205 tdm_buffer_dump_list(&private_capture->buffer_list, str, 256);
207 TDM_WRN("not finished: %s buffers", str);
210 free(private_capture);
214 tdm_capture_destroy(tdm_capture *capture)
216 tdm_private_capture *private_capture = capture;
217 tdm_private_display *private_display;
219 if (!private_capture)
222 private_display = private_capture->private_display;
224 pthread_mutex_lock(&private_display->lock);
225 tdm_capture_destroy_internal(private_capture);
226 pthread_mutex_unlock(&private_display->lock);
230 tdm_capture_set_info(tdm_capture *capture, tdm_info_capture *info)
232 CAPTURE_FUNC_ENTRY();
234 TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
236 pthread_mutex_lock(&private_display->lock);
238 if (!func_capture->capture_set_info) {
239 pthread_mutex_unlock(&private_display->lock);
240 return TDM_ERROR_NONE;
243 ret = func_capture->capture_set_info(private_capture->capture_backend, info);
245 pthread_mutex_unlock(&private_display->lock);
251 tdm_capture_attach(tdm_capture *capture, tbm_surface_h buffer)
253 CAPTURE_FUNC_ENTRY();
255 TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
257 pthread_mutex_lock(&private_display->lock);
259 if (!func_capture->capture_attach) {
260 pthread_mutex_unlock(&private_display->lock);
261 return TDM_ERROR_NONE;
264 tdm_buffer_ref_backend(buffer);
265 ret = func_capture->capture_attach(private_capture->capture_backend, buffer);
267 if (ret == TDM_ERROR_NONE)
268 tdm_buffer_add_list(&private_capture->buffer_list, buffer);
270 if (tdm_debug_buffer) {
271 char str[256] = {0,};
272 tdm_buffer_dump_list(&private_capture->buffer_list, str, 256);
273 TDM_INFO("attached: %s", str);
276 pthread_mutex_unlock(&private_display->lock);
282 tdm_capture_commit(tdm_capture *capture)
284 CAPTURE_FUNC_ENTRY();
286 pthread_mutex_lock(&private_display->lock);
288 if (!func_capture->capture_commit) {
289 pthread_mutex_unlock(&private_display->lock);
290 return TDM_ERROR_NONE;
293 ret = func_capture->capture_commit(private_capture->capture_backend);
295 pthread_mutex_unlock(&private_display->lock);