1 /**************************************************************************
5 Copyright 2014 Samsung Electronics co., Ltd. All Rights Reserved.
7 Contact: SooChan Lim <sc1.lim@samsung.com>, Sangjin Lee <lsj119@samsung.com>
8 Boram Park <boram1288.park@samsung.com>, Changyeon Lee <cyeon.lee@samsung.com>
10 Permission is hereby granted, free of charge, to any person obtaining a
11 copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sub license, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial portions
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 **************************************************************************/
32 #ifndef _TBM_SURFACE_QUEUE_H_
33 #define _TBM_SURFACE_QUEUE_H_
35 #include <tbm_surface.h>
36 #include <tbm_type_common.h>
37 #include <tbm_error.h>
40 TBM_SURFACE_QUEUE_TRACE_NONE = 0,
41 TBM_SURFACE_QUEUE_TRACE_DEQUEUE = 1,
42 TBM_SURFACE_QUEUE_TRACE_ENQUEUE = 2,
43 TBM_SURFACE_QUEUE_TRACE_ACQUIRE = 3,
44 TBM_SURFACE_QUEUE_TRACE_RELEASE = 4,
45 TBM_SURFACE_QUEUE_TRACE_CANCEL_DEQUEUE = 5,
46 TBM_SURFACE_QUEUE_TRACE_CANCEL_ACQUIRE = 6,
47 } tbm_surface_queue_trace;
50 TBM_SURFACE_QUEUE_MODE_NONE = 0,
52 * GUARANTEE_CYCLE mode must do enqueue/aquire/release or cancel_dequeue
53 * for the tbm_surface which is dequeued before tbm_surface_queue is reset.
55 TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE = (1 << 0),
56 } tbm_surface_queue_mode;
58 typedef struct _tbm_surface_queue *tbm_surface_queue_h;
60 typedef void (*tbm_surface_queue_notify_cb)(tbm_surface_queue_h surface_queue,
63 typedef tbm_surface_h(*tbm_surface_alloc_cb)(tbm_surface_queue_h surface_queue,
66 typedef void (*tbm_surface_free_cb)(tbm_surface_queue_h surface_queue,
67 void *data, tbm_surface_h surface);
69 typedef void (*tbm_surface_queue_trace_cb)(tbm_surface_queue_h surface_queue,
70 tbm_surface_h surface, tbm_surface_queue_trace trace, void *data);
77 * @brief Creates the tbm_surface_queue_h.
78 * @details This function creates the tbm_surfac_queue_h with the given queue_size, width, height, format, flags.
80 * @param[in] queue_size The size of the tbm_surface_queue
81 * @param[in] width The width of the tbm_surface_queue
82 * @param[in] height The height of the tbm_surface_queue
83 * @param[in] format The format of the tbm_surface_queue
84 * @param[in] flags The flags of the tbm_surface_queue
86 * @return #tbm_surface_queue_h on success,
89 * @see tbm_surface_queue_destroy()
93 #include <tbm_surface_queue.h>
95 tbm_surface_queue_h surface_queue;
97 surface_queue = tbm_surface_queue_create(3, 128, 128, TBM_FORMAT_ARGB888, TBM_BO_DEFAULT);
101 tbm_surface_queue_destroy (surface_queue);
104 tbm_surface_queue_h tbm_surface_queue_create(int queue_size, int width,
105 int height, int format, int flags);
108 * @brief Creates the sequence tbm_surface_queue_h.
109 * @details This function creates the sequence tbm_surface_queue_h with the given queue_size, width, height, format, flags.
111 * @param[in] queue_size The size of the tbm_surface_queue
112 * @param[in] width The width of the tbm_surface_queue
113 * @param[in] height The height of the tbm_surface_queue
114 * @param[in] format The format of the tbm_surface_queue
115 * @param[in] flags The flags of the tbm_surface_queue
117 * @return #tbm_surface_queue_h on success,
120 * @see tbm_surface_queue_destroy()
124 #include <tbm_surface_queue.h>
126 tbm_surface_queue_h surface_queue;
128 surface_queue = tbm_surface_queue_sequence_create(3, 128, 128, TBM_FORMAT_ARGB888, TBM_BO_DEFAULT);
132 tbm_surface_queue_destroy (surface_queue);
135 tbm_surface_queue_h tbm_surface_queue_sequence_create(int queue_size, int width,
136 int height, int format, int flags);
139 * @brief Destroys the tbm_surface_queue.
141 * @param[in] surface_queue The #tbm_surface_queue_h
143 * @return #TBM_SURFACE_QUEUE_ERROR_NONE on success,
144 * otherwise an error status value
146 * @see tbm_surface_queue_create()
147 * @see tbm_surface_queue_sequence_create()
151 #include <tbm_surface_queue.h>
153 tbm_surface_queue_h surface_queue;
155 surface_queue = tbm_surface_queue_create(3, 128, 128, TBM_FORMAT_ARGB888, TBM_BO_DEFAULT);
159 tbm_surface_queue_destroy(surface_queue);
162 void tbm_surface_queue_destroy(tbm_surface_queue_h surface_queue);
165 * @brief Sets allocate callback to the tbm_surface_queue.
166 * alloc_cb is called when the tbm_surface_queue try to allocate the tbm_surface and
167 * the tbm_surface_queue dequeue the tbm_surface returned in alloc_cb
168 * free_cb is called when the tbm_surface_queue unreference the tbm_surface.
170 * @param[in] surface_queue The #tbm_surface_queue_h
171 * @param[in] alloc_cb The callback of allocate
172 * @param[in] free_cb The callback of free
173 * @param[in] data The user data
175 * @return #TBM_SURFACE_QUEUE_ERROR_NONE on success,
176 * otherwise an error status value
178 tbm_surface_queue_error_e tbm_surface_queue_set_alloc_cb(
179 tbm_surface_queue_h surface_queue,
180 tbm_surface_alloc_cb alloc_cb,
181 tbm_surface_free_cb free_cb,
185 * @brief Gets the width of the tbm_surface_queue.
187 * @param[in] surface_queue The #tbm_surface_queue_h
189 * @return The width of the tbm_surface_queue on success,
190 * otherwise an error status value
192 int tbm_surface_queue_get_width(tbm_surface_queue_h surface_queue);
195 * @brief Gets the height of the tbm_surface_queue.
197 * @param[in] surface_queue The #tbm_surface_queue_h
199 * @return The height of the tbm_surface_queue on success,
200 * otherwise an error status value
202 int tbm_surface_queue_get_height(tbm_surface_queue_h surface_queue);
205 * @brief Gets the format of the tbm_surface_queue.
207 * @param[in] surface_queue The #tbm_surface_queue_h
209 * @return The format of the tbm_surface_queue on success,
210 * otherwise an error status value
212 int tbm_surface_queue_get_format(tbm_surface_queue_h surface_queue);
215 * @brief Gets the size of the tbm_surface_queue.
217 * @param[in] surface_queue The #tbm_surface_queue_h
219 * @return The size of the tbm_surface_queue on success,
220 * otherwise an error status value
222 int tbm_surface_queue_get_size(tbm_surface_queue_h surface_queue);
225 * @brief Gets the tbm_surfaces used by tbm_surface_queue.
226 * Return only surfaces are allocated and current used by the tbm_surface_queue.
227 * the tbm_surface_queue allocate surface when can_dequeue or dequeue.
228 * if the tbm_surface_queue allocate 2 surface even if queue size is 3,
229 * this function will return 2 surfaces.
230 * if the tbm_surface_queue is flushed, this function will return none surfaces.
232 * @remarks You must release the surfaces using free().
234 * @param[in] surface_queue The #tbm_surface_queue_h
235 * @param[out] surfaces The array of the tbm_surfaces
236 * @param[out] num The number of the array
238 * @return #TBM_SURFACE_ERROR_NONE on success,
239 * otherwise an error status value
244 #include <tbm_surface_queue.h>
246 tbm_surface_queue_h surface_queue;
247 tbm_surface_h *surfaces;
249 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
253 tsq_err = tbm_surface_queue_get_surfaces(surface_queue, surfaces, &num);
254 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
264 tbm_surface_queue_error_e tbm_surface_queue_get_surfaces(
265 tbm_surface_queue_h surface_queue,
266 tbm_surface_h *surfaces, int *num);
268 tbm_surface_queue_error_e tbm_surface_queue_get_acquirable_surfaces(
269 tbm_surface_queue_h surface_queue,
270 tbm_surface_h *surfaces, int *num);
273 * @brief Gets number of the tbm_surfaces by tbm_surface_queue_trace.
275 * @param[in] surface_queue The #tbm_surface_queue_h
276 * @param[in] trace The #tbm_surface_queue_trace
277 * @param[out] num The number of the surfaces
279 * @return #TBM_SURFACE_ERROR_NONE on success,
280 * otherwise an error status value
285 #include <tbm_surface_queue.h>
287 tbm_surface_queue_h surface_queue;
289 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
293 tsq_err = tbm_surface_queue_get_trace_surface_num(surface_queue, TBM_SURFACE_QUEUE_TRACE_DEQUEUE, &num);
294 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
302 tbm_surface_queue_error_e tbm_surface_queue_get_trace_surface_num(
303 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace trace, int *num);
306 * @brief Sets size of the tbm_surface_queue.
308 * @param[in] surface_queue The #tbm_surface_queue_h
309 * @param[in] queue_size The size of the tbm_surface_queue
310 * @param[in] flush flush the tbm_surface_queue
312 * @return #TBM_SURFACE_ERROR_NONE on success,
313 * otherwise an error status value
318 #include <tbm_surface_queue.h>
320 tbm_surface_queue_h surface_queue;
321 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
325 tsq_err = tbm_surface_queue_set_size(surface_queue, 2, 1);
326 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
334 tbm_surface_queue_error_e tbm_surface_queue_set_size(
335 tbm_surface_queue_h surface_queue, int queue_size, int flush);
338 * @brief Sets modes of the tbm_surface_queue.
340 * @param[in] surface_queue The #tbm_surface_queue_h
341 * @param[in] modes modes of The #tbm_surface_queue_mode
343 * @return #TBM_SURFACE_ERROR_NONE on success,
344 * otherwise an error status value
349 #include <tbm_surface_queue.h>
351 tbm_surface_queue_h surface_queue;
352 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
354 surface_queue = tbm_surface_queue_create(3, 128, 128, TBM_FORMAT_ARGB888, TBM_BO_DEFAULT);
358 tsq_err = tbm_surface_queue_set_modes(surface_queue, TBM_SURFACE_QUEUE_MODE_GUARANTEE_CYCLE);
359 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
367 tbm_surface_queue_error_e tbm_surface_queue_set_modes(
368 tbm_surface_queue_h surface_queue, int modes);
371 * @brief Sets sync count of the tbm_surface_queue.
373 * @param[in] surface_queue The #tbm_surface_queue_h
374 * @param[in] sync_count The sync count
376 * @return #TBM_SURFACE_ERROR_NONE on success,
377 * otherwise an error status value
379 tbm_surface_queue_error_e tbm_surface_queue_set_sync_count(
380 tbm_surface_queue_h surface_queue, unsigned int sync_count);
383 * @brief Check the tbm_surface_queue can dequeue the tbm_surface.
384 * if wait is 1, this function isn't return until another thread release
385 * the tbm_surface to the tbm_surface_queue
387 * @param[in] surface_queue The #tbm_surface_queue_h
388 * @param[in] wait wait releasing the tbm_surface
390 * @return 1 if it can it, otherwise 0.
395 #include <tbm_surface_queue.h>
397 tbm_surface_queue_h surface_queue;
401 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
409 int tbm_surface_queue_can_dequeue(tbm_surface_queue_h surface_queue, int wait);
412 * @brief Check the tbm_surface_queue can acquire the tbm_surface.
413 * if wait is 1, this function isn't return until another thread enqueue
414 * the tbm_surface to the tbm_surface_queue
416 * @param[in] surface_queue The #tbm_surface_queue_h
417 * @param[in] wait wait enqueueing the tbm_surface
419 * @return 1 if it can it, otherwise 0.
424 #include <tbm_surface_queue.h>
426 tbm_surface_queue_h surface_queue;
430 if (tbm_surface_queue_can_acquire(surface_queue, 0)) {
438 int tbm_surface_queue_can_acquire(tbm_surface_queue_h surface_queue, int wait);
441 * @brief Dequeue the tbm_surface from the tbm_surface_queue.
443 * @param[in] surface_queue The #tbm_surface_queue_h
444 * @param[out] surface The #tbm_surface_h
446 * @return #TBM_SURFACE_ERROR_NONE on success,
447 * otherwise an error status value
452 #include <tbm_surface_queue.h>
454 tbm_surface_queue_h surface_queue;
455 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
456 tbm_surface_h surface;
460 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
461 tsq_err = tbm_surface_queue_dequeue(surface_queue, &surface);
462 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
471 tbm_surface_queue_error_e tbm_surface_queue_dequeue(
472 tbm_surface_queue_h surface_queue, tbm_surface_h *surface);
475 * @brief Enqueue the tbm_surface to the tbm_surface_queue.
477 * @param[in] surface_queue The #tbm_surface_queue_h
478 * @param[in] surface The #tbm_surface_h
480 * @return #TBM_SURFACE_ERROR_NONE on success,
481 * otherwise an error status value
486 #include <tbm_surface_queue.h>
488 tbm_surface_queue_h surface_queue;
489 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
490 tbm_surface_h surface;
492 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
493 tsq_err = tbm_surface_queue_dequeue(surface_queue, &surface);
494 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
503 tsq_err = tbm_surface_queue_enqueue(surface_queue, surface);
504 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
512 tbm_surface_queue_error_e tbm_surface_queue_enqueue(
513 tbm_surface_queue_h surface_queue, tbm_surface_h surface);
516 * @brief Acquire the tbm_surface from the tbm_surface_queue.
518 * @param[in] surface_queue The #tbm_surface_queue_h
519 * @param[out] surface The #tbm_surface_h
521 * @return #TBM_SURFACE_ERROR_NONE on success,
522 * otherwise an error status value
527 #include <tbm_surface_queue.h>
529 tbm_surface_queue_h surface_queue;
530 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
531 tbm_surface_h surface, surface2;
533 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
534 tsq_err = tbm_surface_queue_dequeue(surface_queue, &surface);
535 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
544 tsq_err = tbm_surface_queue_enqueue(surface_queue, surface);
545 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
551 if (tbm_surface_queue_can_acquire(surface_queue, 0)) {
552 tsq_err = tbm_surface_queue_acquire(surface_queue, &surface2)
553 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
562 tbm_surface_queue_error_e tbm_surface_queue_acquire(
563 tbm_surface_queue_h surface_queue, tbm_surface_h *surface);
566 * @brief Release the tbm_surface to the tbm_surface_queue.
567 * the tbm_surface should be released when the tbm_surface can be dequeued and rendered.
568 * if the tbm_surface is released even though consumer is using it, it cause issue.
570 * @param[in] surface_queue The #tbm_surface_queue_h
571 * @param[in] surface The #tbm_surface_h
573 * @return #TBM_SURFACE_ERROR_NONE on success,
574 * otherwise an error status value
579 #include <tbm_surface_queue.h>
581 tbm_surface_queue_h surface_queue;
582 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
583 tbm_surface_h surface, surface2;
585 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
586 tsq_err = tbm_surface_queue_dequeue(surface_queue, &surface);
587 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
596 tsq_err = tbm_surface_queue_enqueue(surface_queue, surface);
597 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
603 if (tbm_surface_queue_can_acquire(surface_queue, 0)) {
604 tsq_err = tbm_surface_queue_acquire(surface_queue, &surface2)
605 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
613 tsq_err = tbm_surface_queue_release(surface_queue, surface2)
614 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
620 tbm_surface_queue_error_e tbm_surface_queue_release(
621 tbm_surface_queue_h surface_queue, tbm_surface_h surface);
624 * @brief Cancel dequeue the tbm_surface to the tbm_surface_queue.
626 * @param[in] surface_queue The #tbm_surface_queue_h
627 * @param[in] surface The #tbm_surface_h
629 * @return #TBM_SURFACE_ERROR_NONE on success,
630 * otherwise an error status value
635 #include <tbm_surface_queue.h>
637 tbm_surface_queue_h surface_queue;
638 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
639 tbm_surface_h surface;
641 if (tbm_surface_queue_can_dequeue(surface_queue, 0)) {
642 tsq_err = tbm_surface_queue_dequeue(surface_queue, &surface);
643 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
650 tsq_err = tbm_surface_queue_cancel_dequeue(surface_queue, surface);
651 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
659 tbm_surface_queue_error_e tbm_surface_queue_cancel_dequeue(
660 tbm_surface_queue_h surface_queue, tbm_surface_h surface);
663 * @brief Cancel acquire the tbm_surface to the tbm_surface_queue.
665 * @param[in] surface_queue The #tbm_surface_queue_h
666 * @param[in] surface The #tbm_surface_h
668 * @return #TBM_SURFACE_ERROR_NONE on success,
669 * otherwise an error status value
674 #include <tbm_surface_queue.h>
676 tbm_surface_queue_h surface_queue;
677 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
678 tbm_surface_h surface;
680 if (tbm_surface_queue_can_acquire(surface_queue, 0)) {
681 tsq_err = tbm_surface_queue_acquire(surface_queue, &surface);
682 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
689 tsq_err = tbm_surface_queue_cancel_acquire(surface_queue, surface);
690 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
698 tbm_surface_queue_error_e tbm_surface_queue_cancel_acquire(
699 tbm_surface_queue_h surface_queue, tbm_surface_h surface);
702 * @brief Reset the tbm_surface_queue.
704 * @param[in] surface_queue The #tbm_surface_queue_h
705 * @param[in] width The width of the tbm_surface_queue
706 * @param[in] height The height of the tbm_surface_queue
707 * @param[in] format The format of the tbm_surface_queue
709 * @return #TBM_SURFACE_ERROR_NONE on success,
710 * otherwise an error status value
715 #include <tbm_surface_queue.h>
717 tbm_surface_queue_h surface_queue;
718 tbm_surface_queue_error_e tsq_err = TBM_SURFACE_QUEUE_ERROR_NONE;
720 tsq_err = tbm_surface_queue_reset(surface_queue, 256,256, TBM_FORMAT_YUV420);
721 if (tsq_err != TBM_SURFACE_QUEUE_ERROR_NONE) {
729 tbm_surface_queue_error_e tbm_surface_queue_reset(
730 tbm_surface_queue_h surface_queue, int width, int height, int format);
733 * @brief Flush the tbm_surface_queue.
735 * @param[in] surface_queue The #tbm_surface_queue_h
737 * @return #TBM_SURFACE_ERROR_NONE on success,
738 * otherwise an error status value
740 tbm_surface_queue_error_e tbm_surface_queue_flush(tbm_surface_queue_h surface_queue);
743 * @brief Free Flush the tbm_surface_queue.
744 * only the released tbm_surface is flushed.
746 * @param[in] surface_queue The #tbm_surface_queue_h
748 * @return #TBM_SURFACE_ERROR_NONE on success,
749 * otherwise an error status value
751 tbm_surface_queue_error_e tbm_surface_queue_free_flush(tbm_surface_queue_h surface_queue);
754 * @brief Notify reset of the tbm_surface_queue.
756 * @param[in] surface_queue The #tbm_surface_queue_h
758 * @return #TBM_SURFACE_ERROR_NONE on success,
759 * otherwise an error status value
761 tbm_surface_queue_error_e tbm_surface_queue_notify_reset(tbm_surface_queue_h surface_queue);
764 * @brief Notify dequeuable of the tbm_surface_queue.
766 * @param[in] surface_queue The #tbm_surface_queue_h
768 * @return #TBM_SURFACE_ERROR_NONE on success,
769 * otherwise an error status value
771 tbm_surface_queue_error_e tbm_surface_queue_notify_dequeuable(tbm_surface_queue_h surface_queue);
774 * @brief Add callback of destroy to the tbm_surface_queue.
776 * @param[in] surface_queue The #tbm_surface_queue_h
777 * @param[in] destroy_cb The callback of destroy
778 * @param[in] data The user data
780 * @return #TBM_SURFACE_ERROR_NONE on success,
781 * otherwise an error status value
783 tbm_surface_queue_error_e tbm_surface_queue_add_destroy_cb(
784 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb,
788 * @brief Remove callback of destroy from the tbm_surface_queue.
790 * @param[in] surface_queue The #tbm_surface_queue_h
791 * @param[in] destroy_cb The callback of destroy
792 * @param[in] data The user data
794 * @return #TBM_SURFACE_ERROR_NONE on success,
795 * otherwise an error status value
797 tbm_surface_queue_error_e tbm_surface_queue_remove_destroy_cb(
798 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb destroy_cb,
802 * @brief Add callback of reset to the tbm_surface_queue.
804 * @param[in] surface_queue The #tbm_surface_queue_h
805 * @param[in] reset_cb The callback of reset
806 * @param[in] data The user data
808 * @return #TBM_SURFACE_ERROR_NONE on success,
809 * otherwise an error status value
811 tbm_surface_queue_error_e tbm_surface_queue_add_reset_cb(
812 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb,
816 * @brief Remove callback of reset from the tbm_surface_queue.
818 * @param[in] surface_queue The #tbm_surface_queue_h
819 * @param[in] reset_cb The callback of reset
820 * @param[in] data The user data
822 * @return #TBM_SURFACE_ERROR_NONE on success,
823 * otherwise an error status value
825 tbm_surface_queue_error_e tbm_surface_queue_remove_reset_cb(
826 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb reset_cb,
830 * @brief Add callback of dequeuable to the tbm_surface_queue.
832 * @param[in] surface_queue The #tbm_surface_queue_h
833 * @param[in] dequeuable_cb The callback of dequeuable
834 * @param[in] data The user data
836 * @return #TBM_SURFACE_ERROR_NONE on success,
837 * otherwise an error status value
839 tbm_surface_queue_error_e tbm_surface_queue_add_dequeuable_cb(
840 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb,
844 * @brief Remove callback of dequeuable from the tbm_surface_queue.
846 * @param[in] surface_queue The #tbm_surface_queue_h
847 * @param[in] dequeuable_cb The callback of dequeuable
848 * @param[in] data The user data
850 * @return #TBM_SURFACE_ERROR_NONE on success,
851 * otherwise an error status value
853 tbm_surface_queue_error_e tbm_surface_queue_remove_dequeuable_cb(
854 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeuable_cb,
858 * @brief Add callback of dequeue to the tbm_surface_queue.
860 * @param[in] surface_queue The #tbm_surface_queue_h
861 * @param[in] dequeue_cb The callback of dequeue
862 * @param[in] data The user data
864 * @return #TBM_SURFACE_ERROR_NONE on success,
865 * otherwise an error status value
867 tbm_surface_queue_error_e tbm_surface_queue_add_dequeue_cb(
868 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb,
872 * @brief Remove callback of dequeue from the tbm_surface_queue.
874 * @param[in] surface_queue The #tbm_surface_queue_h
875 * @param[in] dequeue_cb The callback of dequeue
876 * @param[in] data The user data
878 * @return #TBM_SURFACE_ERROR_NONE on success,
879 * otherwise an error status value
881 tbm_surface_queue_error_e tbm_surface_queue_remove_dequeue_cb(
882 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb dequeue_cb,
886 * @brief Add callback of can_dequeue to the tbm_surface_queue.
888 * @param[in] surface_queue The #tbm_surface_queue_h
889 * @param[in] can_dequeue_cb The callback of can_dequeue
890 * @param[in] data The user data
892 * @return #TBM_SURFACE_ERROR_NONE on success,
893 * otherwise an error status value
895 tbm_surface_queue_error_e tbm_surface_queue_add_can_dequeue_cb(
896 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb,
900 * @brief Remove callback of can_dequeue from the tbm_surface_queue.
902 * @param[in] surface_queue The #tbm_surface_queue_h
903 * @param[in] can_dequeue_cb The callback of can_dequeue
904 * @param[in] data The user data
906 * @return #TBM_SURFACE_ERROR_NONE on success,
907 * otherwise an error status value
909 tbm_surface_queue_error_e tbm_surface_queue_remove_can_dequeue_cb(
910 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb can_dequeue_cb,
914 * @brief Add callback of acquirable to the tbm_surface_queue.
916 * @param[in] surface_queue The #tbm_surface_queue_h
917 * @param[in] acquirable_cb The callback of acquirable
918 * @param[in] data The user data
920 * @return #TBM_SURFACE_ERROR_NONE on success,
921 * otherwise an error status value
923 tbm_surface_queue_error_e tbm_surface_queue_add_acquirable_cb(
924 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb,
928 * @brief Remove callback of acquirable form the tbm_surface_queue.
930 * @param[in] surface_queue The #tbm_surface_queue_h
931 * @param[in] acquirable_cb The callback of acquirable
932 * @param[in] data The user data
934 * @return #TBM_SURFACE_ERROR_NONE on success,
935 * otherwise an error status value
937 tbm_surface_queue_error_e tbm_surface_queue_remove_acquirable_cb(
938 tbm_surface_queue_h surface_queue, tbm_surface_queue_notify_cb acquirable_cb,
942 * @brief Add callback of trace to the tbm_surface_queue.
944 * @param[in] surface_queue The #tbm_surface_queue_h
945 * @param[in] trace_cb The callback of trace
946 * @param[in] data The user data
948 * @return #TBM_SURFACE_ERROR_NONE on success,
949 * otherwise an error status value
951 tbm_surface_queue_error_e tbm_surface_queue_add_trace_cb(
952 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb,
956 * @brief Remove callback of trace from the tbm_surface_queue.
958 * @param[in] surface_queue The #tbm_surface_queue_h
959 * @param[in] trace_cb The callback of trace
960 * @param[in] data The user data
962 * @return #TBM_SURFACE_ERROR_NONE on success,
963 * otherwise an error status value
965 tbm_surface_queue_error_e tbm_surface_queue_remove_trace_cb(
966 tbm_surface_queue_h surface_queue, tbm_surface_queue_trace_cb trace_cb,
969 tbm_surface_queue_error_e
970 tbm_surface_queue_can_dequeue_wait_timeout(
971 tbm_surface_queue_h surface_queue, int ms_timeout);
976 #endif /* _TBM_SURFACE_H_ */