add layer_set_video_pos to backend interface
[platform/core/uifw/libtdm.git] / src / tdm_display.c
1 /**************************************************************************
2
3 libtdm
4
5 Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
6
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>
13
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:
21
22 The above copyright notice and this permission notice (including the
23 next paragraph) shall be included in all copies or substantial portions
24 of the Software.
25
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.
33
34 **************************************************************************/
35
36 #ifdef HAVE_CONFIG_H
37 #include "config.h"
38 #endif
39
40 #include "tdm.h"
41 #include "tdm_backend.h"
42 #include "tdm_private.h"
43
44 #define COUNT_MAX   10
45
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;
51
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;
57
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
65
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
73
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
83
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
93
94 EXTERN tdm_error
95 tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities)
96 {
97     DISPLAY_FUNC_ENTRY();
98
99     TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
100
101     pthread_mutex_lock(&private_display->lock);
102
103     *capabilities = private_display->capabilities;
104
105     pthread_mutex_unlock(&private_display->lock);
106
107     return ret;
108 }
109
110 EXTERN tdm_error
111 tdm_display_get_pp_capabilities(tdm_display *dpy, tdm_pp_capability *capabilities)
112 {
113     DISPLAY_FUNC_ENTRY();
114
115     TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
116
117     pthread_mutex_lock(&private_display->lock);
118
119     *capabilities = private_display->caps_pp.capabilities;
120
121     pthread_mutex_unlock(&private_display->lock);
122
123     return ret;
124 }
125
126 EXTERN tdm_error
127 tdm_display_get_pp_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
128 {
129     DISPLAY_FUNC_ENTRY();
130
131     TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
132     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
133
134     pthread_mutex_lock(&private_display->lock);
135
136     *formats = (const tbm_format*)private_display->caps_pp.formats;
137     *count = private_display->caps_pp.format_count;
138
139     pthread_mutex_unlock(&private_display->lock);
140
141     return ret;
142 }
143
144 EXTERN tdm_error
145 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
146                                   int *max_w, int *max_h, int *preferred_align)
147 {
148     DISPLAY_FUNC_ENTRY();
149
150     pthread_mutex_lock(&private_display->lock);
151
152     if (min_w)
153         *min_w = private_display->caps_pp.min_w;
154     if (min_h)
155         *min_h = private_display->caps_pp.min_h;
156     if (max_w)
157         *max_w = private_display->caps_pp.max_w;
158     if (max_h)
159         *max_h = private_display->caps_pp.max_h;
160     if (preferred_align)
161         *preferred_align = private_display->caps_pp.preferred_align;
162
163     pthread_mutex_unlock(&private_display->lock);
164
165     return ret;
166 }
167
168 EXTERN tdm_error
169 tdm_display_get_capture_capabilities(tdm_display *dpy, tdm_capture_capability *capabilities)
170 {
171     DISPLAY_FUNC_ENTRY();
172
173     TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
174
175     pthread_mutex_lock(&private_display->lock);
176
177     *capabilities = private_display->caps_capture.capabilities;
178
179     pthread_mutex_unlock(&private_display->lock);
180
181     return ret;
182 }
183
184 EXTERN tdm_error
185 tdm_display_get_catpure_available_formats(tdm_display *dpy, const tbm_format **formats, int *count)
186 {
187     DISPLAY_FUNC_ENTRY();
188
189     TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
190     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
191
192     pthread_mutex_lock(&private_display->lock);
193
194     *formats = (const tbm_format*)private_display->caps_capture.formats;
195     *count = private_display->caps_capture.format_count;
196
197     pthread_mutex_unlock(&private_display->lock);
198
199     return ret;
200 }
201
202 EXTERN tdm_error
203 tdm_display_get_output_count(tdm_display *dpy, int *count)
204 {
205     tdm_private_output *private_output = NULL;
206
207     DISPLAY_FUNC_ENTRY();
208
209     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
210
211     pthread_mutex_lock(&private_display->lock);
212
213     *count = 0;
214     LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
215         (*count)++;
216
217     if (*count == 0)
218     {
219         pthread_mutex_unlock(&private_display->lock);
220         return TDM_ERROR_NONE;
221     }
222
223     pthread_mutex_unlock(&private_display->lock);
224
225     return ret;
226 }
227
228
229 EXTERN const tdm_output*
230 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
231 {
232     tdm_private_output *private_output = NULL;
233     int i = 0;
234
235     DISPLAY_FUNC_ENTRY_ERROR();
236
237     pthread_mutex_lock(&private_display->lock);
238
239     if (error)
240         *error = TDM_ERROR_NONE;
241
242     i = 0;
243     LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
244     {
245         if (i == index)
246         {
247             pthread_mutex_unlock(&private_display->lock);
248             return (const tdm_output*)private_output;
249         }
250         i++;
251     }
252
253     pthread_mutex_unlock(&private_display->lock);
254
255     return NULL;
256 }
257
258 EXTERN tdm_error
259 tdm_display_get_fd(tdm_display *dpy, int *fd)
260 {
261     tdm_func_display *func_display;
262     DISPLAY_FUNC_ENTRY();
263
264     TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
265
266     pthread_mutex_lock(&private_display->lock);
267
268     func_display = &private_display->func_display;
269
270     if (!func_display->display_get_fd)
271     {
272         pthread_mutex_unlock(&private_display->lock);
273         return TDM_ERROR_NONE;
274     }
275
276     ret = func_display->display_get_fd(private_display->bdata, fd);
277
278     pthread_mutex_unlock(&private_display->lock);
279
280     return ret;
281 }
282
283 EXTERN tdm_error
284 tdm_display_handle_events(tdm_display *dpy)
285 {
286     tdm_func_display *func_display;
287     DISPLAY_FUNC_ENTRY();
288
289     pthread_mutex_lock(&private_display->lock);
290
291     func_display = &private_display->func_display;
292
293     if (!func_display->display_handle_events)
294     {
295         pthread_mutex_unlock(&private_display->lock);
296         return TDM_ERROR_NONE;
297     }
298
299     ret = func_display->display_handle_events(private_display->bdata);
300
301     pthread_mutex_unlock(&private_display->lock);
302
303     return ret;
304 }
305
306 EXTERN tdm_pp*
307 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
308 {
309     tdm_pp *pp;
310
311     DISPLAY_FUNC_ENTRY_ERROR();
312
313     pthread_mutex_lock(&private_display->lock);
314
315     pp = (tdm_pp*)tdm_pp_create_internal(private_display, error);
316
317     pthread_mutex_unlock(&private_display->lock);
318
319     return pp;
320 }
321
322 EXTERN tdm_error
323 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
324 {
325     OUTPUT_FUNC_ENTRY();
326
327     TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
328
329     pthread_mutex_lock(&private_display->lock);
330
331     *status = private_output->caps.status;
332
333     pthread_mutex_unlock(&private_display->lock);
334
335     return ret;
336 }
337
338 EXTERN tdm_error
339 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
340 {
341     OUTPUT_FUNC_ENTRY();
342
343     TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
344
345     pthread_mutex_lock(&private_display->lock);
346
347     *type = private_output->caps.type;
348
349     pthread_mutex_unlock(&private_display->lock);
350
351     return ret;
352 }
353
354 EXTERN tdm_error
355 tdm_output_get_layer_count(tdm_output *output, int *count)
356 {
357     tdm_private_layer *private_layer = NULL;
358
359     OUTPUT_FUNC_ENTRY();
360
361     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
362
363     pthread_mutex_lock(&private_display->lock);
364
365     *count = 0;
366     LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
367         (*count)++;
368     if (*count == 0)
369     {
370         pthread_mutex_unlock(&private_display->lock);
371         return TDM_ERROR_NONE;
372     }
373
374     pthread_mutex_unlock(&private_display->lock);
375
376     return ret;
377 }
378
379
380 EXTERN const tdm_layer*
381 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
382 {
383     tdm_private_layer *private_layer = NULL;
384     int i = 0;
385
386     OUTPUT_FUNC_ENTRY_ERROR();
387
388     pthread_mutex_lock(&private_display->lock);
389
390     if (error)
391         *error = TDM_ERROR_NONE;
392
393     LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
394     {
395         if (i == index)
396         {
397             pthread_mutex_unlock(&private_display->lock);
398             return private_layer;
399         }
400         i++;
401     }
402
403     pthread_mutex_unlock(&private_display->lock);
404
405     return NULL;
406 }
407
408 EXTERN tdm_error
409 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props, int *count)
410 {
411     OUTPUT_FUNC_ENTRY();
412
413     TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
414     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
415
416     pthread_mutex_lock(&private_display->lock);
417
418     *props = (const tdm_prop*)private_output->caps.props;
419     *count = private_output->caps.prop_count;
420
421     pthread_mutex_unlock(&private_display->lock);
422
423     return ret;
424 }
425
426 EXTERN tdm_error
427 tdm_output_get_available_modes(tdm_output *output, const tdm_output_mode **modes, int *count)
428 {
429     OUTPUT_FUNC_ENTRY();
430
431     TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
432     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
433
434     pthread_mutex_lock(&private_display->lock);
435
436     *modes = (const tdm_output_mode*)private_output->caps.modes;
437     *count = private_output->caps.mode_count;
438
439     pthread_mutex_unlock(&private_display->lock);
440
441     return ret;
442 }
443
444 EXTERN tdm_error
445 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
446                               int *max_w, int *max_h, int *preferred_align)
447 {
448     OUTPUT_FUNC_ENTRY();
449
450     pthread_mutex_lock(&private_display->lock);
451
452     if (min_w)
453         *min_w = private_output->caps.min_w;
454     if (min_h)
455         *min_h = private_output->caps.min_h;
456     if (max_w)
457         *max_w = private_output->caps.max_w;
458     if (max_h)
459         *max_h = private_output->caps.max_h;
460     if (preferred_align)
461         *preferred_align = private_output->caps.preferred_align;
462
463     pthread_mutex_unlock(&private_display->lock);
464
465     return ret;
466 }
467
468 EXTERN tdm_error
469 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth, unsigned int *mmHeight)
470 {
471     OUTPUT_FUNC_ENTRY();
472
473     pthread_mutex_lock(&private_display->lock);
474
475     if (mmWidth)
476         *mmWidth = private_output->caps.mmWidth;
477     if (mmHeight)
478         *mmHeight = private_output->caps.mmHeight;
479
480     pthread_mutex_unlock(&private_display->lock);
481
482     return ret;
483 }
484
485 EXTERN tdm_error
486 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
487 {
488     OUTPUT_FUNC_ENTRY();
489     TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
490
491     pthread_mutex_lock(&private_display->lock);
492
493     *subpixel = private_output->caps.subpixel;
494
495     pthread_mutex_unlock(&private_display->lock);
496
497     return ret;
498 }
499
500 EXTERN tdm_error
501 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
502 {
503     OUTPUT_FUNC_ENTRY();
504     TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
505
506     pthread_mutex_lock(&private_display->lock);
507
508     *pipe = private_output->pipe;
509
510     pthread_mutex_unlock(&private_display->lock);
511
512     return ret;
513 }
514
515
516 EXTERN tdm_error
517 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
518 {
519     tdm_func_display *func_display;
520     OUTPUT_FUNC_ENTRY();
521
522     pthread_mutex_lock(&private_display->lock);
523
524     func_display = &private_display->func_display;
525
526     if (!func_display->output_set_property)
527     {
528         pthread_mutex_unlock(&private_display->lock);
529         return TDM_ERROR_NONE;
530     }
531
532     ret = func_display->output_set_property(private_output->output_backend, id, value);
533
534     pthread_mutex_unlock(&private_display->lock);
535
536     return ret;
537 }
538
539 EXTERN tdm_error
540 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
541 {
542     tdm_func_display *func_display;
543     OUTPUT_FUNC_ENTRY();
544
545     TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
546
547     pthread_mutex_lock(&private_display->lock);
548
549     func_display = &private_display->func_display;
550
551     if (!func_display->output_get_property)
552     {
553         pthread_mutex_unlock(&private_display->lock);
554         return TDM_ERROR_NONE;
555     }
556
557     ret = func_display->output_get_property(private_output->output_backend, id, value);
558
559     pthread_mutex_unlock(&private_display->lock);
560
561     return ret;
562 }
563
564 static void
565 _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
566                       unsigned int tv_sec, unsigned int tv_usec, void *user_data)
567 {
568     tdm_private_vblank_handler *vblank_handler = user_data;
569     tdm_private_display *private_display;
570
571     TDM_RETURN_IF_FAIL(vblank_handler);
572
573     private_display = vblank_handler->private_output->private_display;
574
575     if (vblank_handler->func)
576     {
577         pthread_mutex_unlock(&private_display->lock);
578         vblank_handler->func(vblank_handler->private_output, sequence,
579                              tv_sec, tv_usec, vblank_handler->user_data);
580         pthread_mutex_lock(&private_display->lock);
581     }
582
583     LIST_DEL(&vblank_handler->link);
584     free(vblank_handler);
585 }
586
587 static void
588 _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
589                       unsigned int tv_sec, unsigned int tv_usec, void *user_data)
590 {
591     tdm_private_commit_handler *commit_handler = user_data;
592     tdm_private_display *private_display;
593     tdm_private_output *private_output;
594     tdm_private_layer *private_layer;
595
596     TDM_RETURN_IF_FAIL(commit_handler);
597
598     private_output = commit_handler->private_output;
599     private_display = private_output->private_display;
600
601     if (commit_handler->func)
602     {
603         pthread_mutex_unlock(&private_display->lock);
604         commit_handler->func(private_output, sequence,
605                              tv_sec, tv_usec, commit_handler->user_data);
606         pthread_mutex_lock(&private_display->lock);
607     }
608
609     LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
610     {
611         if (!private_layer->waiting_buffer)
612             continue;
613
614         if (private_layer->showing_buffer)
615         {
616             pthread_mutex_unlock(&private_display->lock);
617             tdm_buffer_unref_backend(private_layer->showing_buffer);
618             pthread_mutex_lock(&private_display->lock);
619         }
620
621         private_layer->showing_buffer = private_layer->waiting_buffer;
622         private_layer->waiting_buffer = NULL;
623     }
624
625     LIST_DEL(&commit_handler->link);
626     free(commit_handler);
627 }
628
629 EXTERN tdm_error
630 tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
631                        tdm_output_vblank_handler func, void *user_data)
632 {
633     tdm_func_display *func_display;
634     tdm_private_vblank_handler *vblank_handler;
635     OUTPUT_FUNC_ENTRY();
636
637     pthread_mutex_lock(&private_display->lock);
638
639     func_display = &private_display->func_display;
640
641     if (!func_display->output_wait_vblank)
642     {
643         pthread_mutex_unlock(&private_display->lock);
644         return TDM_ERROR_NONE;
645     }
646
647     vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
648     if (!vblank_handler)
649     {
650         TDM_ERR("failed: alloc memory");
651         pthread_mutex_unlock(&private_display->lock);
652         return TDM_ERROR_OUT_OF_MEMORY;
653     }
654
655     LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
656     vblank_handler->private_output = private_output;
657     vblank_handler->func = func;
658     vblank_handler->user_data = user_data;
659
660     ret = func_display->output_wait_vblank(private_output->output_backend, interval,
661                                            sync, vblank_handler);
662     if (ret != TDM_ERROR_NONE)
663     {
664         pthread_mutex_unlock(&private_display->lock);
665         return ret;
666     }
667
668     if (!private_output->regist_vblank_cb)
669     {
670         private_output->regist_vblank_cb = 1;
671         ret = func_display->output_set_vblank_handler(private_output->output_backend,
672                                                       _tdm_output_cb_vblank);
673     }
674
675     pthread_mutex_unlock(&private_display->lock);
676
677     return ret;
678 }
679
680 EXTERN tdm_error
681 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
682 {
683     tdm_func_display *func_display;
684     tdm_private_commit_handler *commit_handler;
685     OUTPUT_FUNC_ENTRY();
686
687     pthread_mutex_lock(&private_display->lock);
688
689     func_display = &private_display->func_display;
690
691     if (!func_display->output_commit)
692     {
693         pthread_mutex_unlock(&private_display->lock);
694         return TDM_ERROR_NONE;
695     }
696
697     commit_handler = calloc(1, sizeof(tdm_private_commit_handler));
698     if (!commit_handler)
699     {
700         TDM_ERR("failed: alloc memory");
701         pthread_mutex_unlock(&private_display->lock);
702         return TDM_ERROR_OUT_OF_MEMORY;
703     }
704
705     LIST_ADD(&commit_handler->link, &private_output->commit_handler_list);
706     commit_handler->private_output = private_output;
707     commit_handler->func = func;
708     commit_handler->user_data = user_data;
709
710     ret = func_display->output_commit(private_output->output_backend, sync, commit_handler);
711     if (ret != TDM_ERROR_NONE)
712     {
713         pthread_mutex_unlock(&private_display->lock);
714         return ret;
715     }
716
717     if (!private_output->regist_commit_cb)
718     {
719         private_output->regist_commit_cb = 1;
720         ret = func_display->output_set_commit_handler(private_output->output_backend,
721                                                       _tdm_output_cb_commit);
722     }
723
724     pthread_mutex_unlock(&private_display->lock);
725
726     return ret;
727 }
728
729 EXTERN tdm_error
730 tdm_output_set_mode(tdm_output *output, tdm_output_mode *mode)
731 {
732     tdm_func_display *func_display;
733     OUTPUT_FUNC_ENTRY();
734
735     TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
736
737     pthread_mutex_lock(&private_display->lock);
738
739     func_display = &private_display->func_display;
740
741     if (!func_display->output_set_mode)
742     {
743         pthread_mutex_unlock(&private_display->lock);
744         return TDM_ERROR_NONE;
745     }
746
747     ret = func_display->output_set_mode(private_output->output_backend, mode);
748
749     pthread_mutex_unlock(&private_display->lock);
750
751     return ret;
752 }
753
754 EXTERN tdm_error
755 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
756 {
757     tdm_func_display *func_display;
758     OUTPUT_FUNC_ENTRY();
759
760     TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
761
762     pthread_mutex_lock(&private_display->lock);
763
764     func_display = &private_display->func_display;
765
766     if (!func_display->output_get_mode)
767     {
768         pthread_mutex_unlock(&private_display->lock);
769         return TDM_ERROR_NONE;
770     }
771
772     ret = func_display->output_get_mode(private_output->output_backend, mode);
773
774     pthread_mutex_unlock(&private_display->lock);
775
776     return ret;
777 }
778
779 EXTERN tdm_error
780 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
781 {
782     tdm_func_display *func_display;
783     OUTPUT_FUNC_ENTRY();
784
785     TDM_RETURN_VAL_IF_FAIL(dpms_value >= TDM_OUTPUT_DPMS_ON, TDM_ERROR_INVALID_PARAMETER);
786     TDM_RETURN_VAL_IF_FAIL(dpms_value < TDM_OUTPUT_DPMS_MAX, TDM_ERROR_INVALID_PARAMETER);
787
788     pthread_mutex_lock(&private_display->lock);
789
790     func_display = &private_display->func_display;
791
792     if (!func_display->output_set_dpms)
793     {
794         pthread_mutex_unlock(&private_display->lock);
795         return TDM_ERROR_NONE;
796     }
797
798     ret = func_display->output_set_dpms(private_output->output_backend, dpms_value);
799
800     pthread_mutex_unlock(&private_display->lock);
801
802     return ret;
803 }
804
805 EXTERN tdm_error
806 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
807 {
808     tdm_func_display *func_display;
809     OUTPUT_FUNC_ENTRY();
810
811     TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
812
813     pthread_mutex_lock(&private_display->lock);
814
815     func_display = &private_display->func_display;
816
817     if (!func_display->output_get_dpms)
818     {
819         pthread_mutex_unlock(&private_display->lock);
820         return TDM_ERROR_NONE;
821     }
822
823     ret = func_display->output_get_dpms(private_output->output_backend, dpms_value);
824
825     pthread_mutex_unlock(&private_display->lock);
826
827     return ret;
828 }
829
830 EXTERN tdm_capture*
831 tdm_output_create_capture(tdm_output *output, tdm_error *error)
832 {
833     tdm_capture *capture = NULL;
834
835     OUTPUT_FUNC_ENTRY_ERROR();
836
837     pthread_mutex_lock(&private_display->lock);
838
839     capture = (tdm_capture*)tdm_capture_create_output_internal(private_output, error);
840
841     pthread_mutex_unlock(&private_display->lock);
842
843     return capture;
844 }
845
846 EXTERN tdm_error
847 tdm_layer_get_capabilities(tdm_layer *layer, tdm_layer_capability *capabilities)
848 {
849     LAYER_FUNC_ENTRY();
850
851     TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
852
853     pthread_mutex_lock(&private_display->lock);
854
855     *capabilities = private_layer->caps.capabilities;
856
857     pthread_mutex_unlock(&private_display->lock);
858
859     return ret;
860 }
861
862 EXTERN tdm_error
863 tdm_layer_get_available_formats(tdm_layer *layer, const tbm_format **formats, int *count)
864 {
865     LAYER_FUNC_ENTRY();
866
867     TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
868     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
869
870     pthread_mutex_lock(&private_display->lock);
871
872     *formats = (const tbm_format*)private_layer->caps.formats;
873     *count = private_layer->caps.format_count;
874
875     pthread_mutex_unlock(&private_display->lock);
876
877     return ret;
878 }
879
880 EXTERN tdm_error
881 tdm_layer_get_available_properties(tdm_layer *layer, const tdm_prop **props, int *count)
882 {
883     LAYER_FUNC_ENTRY();
884
885     TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
886     TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
887
888     pthread_mutex_lock(&private_display->lock);
889
890     *props = (const tdm_prop*)private_layer->caps.props;
891     *count = private_layer->caps.prop_count;
892
893     pthread_mutex_unlock(&private_display->lock);
894
895     return ret;
896 }
897
898 EXTERN tdm_error
899 tdm_layer_get_zpos(tdm_layer *layer, unsigned int *zpos)
900 {
901     LAYER_FUNC_ENTRY();
902
903     TDM_RETURN_VAL_IF_FAIL(zpos != NULL, TDM_ERROR_INVALID_PARAMETER);
904
905     pthread_mutex_lock(&private_display->lock);
906
907     *zpos = private_layer->caps.zpos;
908
909     pthread_mutex_unlock(&private_display->lock);
910
911     return ret;
912 }
913
914 EXTERN tdm_error
915 tdm_layer_set_property(tdm_layer *layer, unsigned int id, tdm_value value)
916 {
917     tdm_func_display *func_display;
918     LAYER_FUNC_ENTRY();
919
920     pthread_mutex_lock(&private_display->lock);
921
922     func_display = &private_display->func_display;
923
924     if (!func_display->layer_set_property)
925     {
926         pthread_mutex_unlock(&private_display->lock);
927         return TDM_ERROR_NONE;
928     }
929
930     ret = func_display->layer_set_property(private_layer->layer_backend, id, value);
931
932     pthread_mutex_unlock(&private_display->lock);
933
934     return ret;
935 }
936
937 EXTERN tdm_error
938 tdm_layer_get_property(tdm_layer *layer, unsigned int id, tdm_value *value)
939 {
940     tdm_func_display *func_display;
941     LAYER_FUNC_ENTRY();
942
943     TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
944
945     pthread_mutex_lock(&private_display->lock);
946
947     func_display = &private_display->func_display;
948
949     if (!func_display->layer_get_property)
950     {
951         pthread_mutex_unlock(&private_display->lock);
952         return TDM_ERROR_NONE;
953     }
954
955     ret = func_display->layer_get_property(private_layer->layer_backend, id, value);
956
957     pthread_mutex_unlock(&private_display->lock);
958
959     return ret;
960 }
961
962 EXTERN tdm_error
963 tdm_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
964 {
965     tdm_func_display *func_display;
966     LAYER_FUNC_ENTRY();
967
968     TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
969
970     pthread_mutex_lock(&private_display->lock);
971
972     func_display = &private_display->func_display;
973
974     private_layer->usable = 0;
975
976     if (!func_display->layer_set_info)
977     {
978         pthread_mutex_unlock(&private_display->lock);
979         return TDM_ERROR_NONE;
980     }
981
982     ret = func_display->layer_set_info(private_layer->layer_backend, info);
983
984     pthread_mutex_unlock(&private_display->lock);
985
986     return ret;
987 }
988
989 EXTERN tdm_error
990 tdm_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
991 {
992     tdm_func_display *func_display;
993     LAYER_FUNC_ENTRY();
994
995     TDM_RETURN_VAL_IF_FAIL(info != NULL, TDM_ERROR_INVALID_PARAMETER);
996
997     pthread_mutex_lock(&private_display->lock);
998
999     func_display = &private_display->func_display;
1000
1001     if (!func_display->layer_get_info)
1002     {
1003         pthread_mutex_unlock(&private_display->lock);
1004         return TDM_ERROR_NONE;
1005     }
1006
1007     ret = func_display->layer_get_info(private_layer->layer_backend, info);
1008
1009     pthread_mutex_unlock(&private_display->lock);
1010
1011     return ret;
1012 }
1013
1014 EXTERN tdm_error
1015 tdm_layer_set_buffer(tdm_layer *layer, tdm_buffer *buffer)
1016 {
1017     tdm_func_display *func_display;
1018     LAYER_FUNC_ENTRY();
1019
1020     TDM_RETURN_VAL_IF_FAIL(buffer != NULL, TDM_ERROR_INVALID_PARAMETER);
1021
1022     pthread_mutex_lock(&private_display->lock);
1023
1024     func_display = &private_display->func_display;
1025
1026     private_layer->usable = 0;
1027
1028     if (!func_display->layer_set_buffer)
1029     {
1030         pthread_mutex_unlock(&private_display->lock);
1031         return TDM_ERROR_NONE;
1032     }
1033
1034     if (private_layer->waiting_buffer)
1035     {
1036         pthread_mutex_unlock(&private_display->lock);
1037         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1038         pthread_mutex_lock(&private_display->lock);
1039     }
1040
1041     private_layer->waiting_buffer = tdm_buffer_ref_backend(buffer);
1042
1043     ret = func_display->layer_set_buffer(private_layer->layer_backend, buffer);
1044
1045     pthread_mutex_unlock(&private_display->lock);
1046
1047     return ret;
1048 }
1049
1050 EXTERN tdm_error
1051 tdm_layer_unset_buffer(tdm_layer *layer)
1052 {
1053     tdm_func_display *func_display;
1054     LAYER_FUNC_ENTRY();
1055
1056     pthread_mutex_lock(&private_display->lock);
1057
1058     func_display = &private_display->func_display;
1059
1060     if (private_layer->waiting_buffer)
1061     {
1062         pthread_mutex_unlock(&private_display->lock);
1063         tdm_buffer_unref_backend(private_layer->waiting_buffer);
1064         pthread_mutex_lock(&private_display->lock);
1065         private_layer->waiting_buffer = NULL;
1066     }
1067
1068     if (private_layer->showing_buffer)
1069     {
1070         pthread_mutex_unlock(&private_display->lock);
1071         tdm_buffer_unref_backend(private_layer->showing_buffer);
1072         pthread_mutex_lock(&private_display->lock);
1073         private_layer->showing_buffer = NULL;
1074     }
1075
1076     private_layer->usable = 1;
1077
1078     if (!func_display->layer_unset_buffer)
1079     {
1080         pthread_mutex_unlock(&private_display->lock);
1081         return TDM_ERROR_NONE;
1082     }
1083
1084     ret = func_display->layer_unset_buffer(private_layer->layer_backend);
1085
1086     pthread_mutex_unlock(&private_display->lock);
1087
1088     return ret;
1089 }
1090
1091 EXTERN tdm_error
1092 tdm_layer_is_usable(tdm_layer *layer, unsigned int *usable)
1093 {
1094     LAYER_FUNC_ENTRY();
1095
1096     TDM_RETURN_VAL_IF_FAIL(usable != NULL, TDM_ERROR_INVALID_PARAMETER);
1097
1098     pthread_mutex_lock(&private_display->lock);
1099
1100     *usable = private_layer->usable;
1101
1102     pthread_mutex_unlock(&private_display->lock);
1103
1104     return ret;
1105 }
1106
1107 EXTERN tdm_error
1108 tdm_layer_set_video_pos(tdm_layer *layer, int zpos)
1109 {
1110     tdm_func_display *func_display;
1111     LAYER_FUNC_ENTRY();
1112
1113     pthread_mutex_lock(&private_display->lock);
1114
1115     func_display = &private_display->func_display;
1116
1117     if (!(private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO))
1118     {
1119         TDM_ERR("layer is not video layer");
1120         pthread_mutex_unlock(&private_display->lock);
1121         return TDM_ERROR_INVALID_PARAMETER;
1122     }
1123
1124     if (!func_display->layer_set_video_pos)
1125     {
1126         pthread_mutex_unlock(&private_display->lock);
1127         return TDM_ERROR_NONE;
1128     }
1129
1130     ret = func_display->layer_set_video_pos(private_layer->layer_backend, zpos);
1131
1132     pthread_mutex_unlock(&private_display->lock);
1133
1134     return ret;
1135 }
1136
1137 EXTERN tdm_capture*
1138 tdm_layer_create_capture(tdm_layer *layer, tdm_error *error)
1139 {
1140     tdm_capture *capture = NULL;
1141
1142     LAYER_FUNC_ENTRY_ERROR();
1143
1144     pthread_mutex_lock(&private_display->lock);
1145
1146     capture = (tdm_capture*)tdm_capture_create_layer_internal(private_layer, error);
1147
1148     pthread_mutex_unlock(&private_display->lock);
1149
1150     return capture;
1151 }