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 **************************************************************************/
33 #include "tbm_bufmgr.h"
34 #include "tbm_bufmgr_int.h"
35 #include "tbm_surface_internal.h"
38 static tbm_bufmgr g_surface_bufmgr;
39 static pthread_mutex_t tbm_surface_lock;
42 _tbm_surface_internal_format_to_str(tbm_format format)
46 return "TBM_FORMAT_C8";
47 case TBM_FORMAT_RGB332:
48 return "TBM_FORMAT_RGB332";
49 case TBM_FORMAT_BGR233:
50 return "TBM_FORMAT_BGR233";
51 case TBM_FORMAT_XRGB4444:
52 return "TBM_FORMAT_XRGB4444";
53 case TBM_FORMAT_XBGR4444:
54 return "TBM_FORMAT_XBGR4444";
55 case TBM_FORMAT_RGBX4444:
56 return "TBM_FORMAT_RGBX4444";
57 case TBM_FORMAT_BGRX4444:
58 return "TBM_FORMAT_BGRX4444";
59 case TBM_FORMAT_ARGB4444:
60 return "TBM_FORMAT_ARGB4444";
61 case TBM_FORMAT_ABGR4444:
62 return "TBM_FORMAT_ABGR4444";
63 case TBM_FORMAT_RGBA4444:
64 return "TBM_FORMAT_RGBA4444";
65 case TBM_FORMAT_BGRA4444:
66 return "TBM_FORMAT_BGRA4444";
67 case TBM_FORMAT_XRGB1555:
68 return "TBM_FORMAT_XRGB1555";
69 case TBM_FORMAT_XBGR1555:
70 return "TBM_FORMAT_XBGR1555";
71 case TBM_FORMAT_RGBX5551:
72 return "TBM_FORMAT_RGBX5551";
73 case TBM_FORMAT_BGRX5551:
74 return "TBM_FORMAT_BGRX5551";
75 case TBM_FORMAT_ARGB1555:
76 return "TBM_FORMAT_ARGB1555";
77 case TBM_FORMAT_ABGR1555:
78 return "TBM_FORMAT_ABGR1555";
79 case TBM_FORMAT_RGBA5551:
80 return "TBM_FORMAT_RGBA5551";
81 case TBM_FORMAT_BGRA5551:
82 return "TBM_FORMAT_BGRA5551";
83 case TBM_FORMAT_RGB565:
84 return "TBM_FORMAT_RGB565";
85 case TBM_FORMAT_BGR565:
86 return "TBM_FORMAT_BGR565";
87 case TBM_FORMAT_RGB888:
88 return "TBM_FORMAT_RGB888";
89 case TBM_FORMAT_BGR888:
90 return "TBM_FORMAT_BGR888";
91 case TBM_FORMAT_XRGB8888:
92 return "TBM_FORMAT_XRGB8888";
93 case TBM_FORMAT_XBGR8888:
94 return "TBM_FORMAT_XBGR8888";
95 case TBM_FORMAT_RGBX8888:
96 return "TBM_FORMAT_RGBX8888";
97 case TBM_FORMAT_BGRX8888:
98 return "TBM_FORMAT_BGRX8888";
99 case TBM_FORMAT_ARGB8888:
100 return "TBM_FORMAT_ARGB8888";
101 case TBM_FORMAT_ABGR8888:
102 return "TBM_FORMAT_ABGR8888";
103 case TBM_FORMAT_RGBA8888:
104 return "TBM_FORMAT_RGBA8888";
105 case TBM_FORMAT_BGRA8888:
106 return "TBM_FORMAT_BGRA8888";
107 case TBM_FORMAT_XRGB2101010:
108 return "TBM_FORMAT_XRGB2101010";
109 case TBM_FORMAT_XBGR2101010:
110 return "TBM_FORMAT_XBGR2101010";
111 case TBM_FORMAT_RGBX1010102:
112 return "TBM_FORMAT_RGBX1010102";
113 case TBM_FORMAT_BGRX1010102:
114 return "TBM_FORMAT_BGRX1010102";
115 case TBM_FORMAT_ARGB2101010:
116 return "TBM_FORMAT_ARGB2101010";
117 case TBM_FORMAT_ABGR2101010:
118 return "TBM_FORMAT_ABGR2101010";
119 case TBM_FORMAT_RGBA1010102:
120 return "TBM_FORMAT_RGBA1010102";
121 case TBM_FORMAT_BGRA1010102:
122 return "TBM_FORMAT_BGRA1010102";
123 case TBM_FORMAT_YUYV:
124 return "TBM_FORMAT_YUYV";
125 case TBM_FORMAT_YVYU:
126 return "TBM_FORMAT_YVYU";
127 case TBM_FORMAT_UYVY:
128 return "TBM_FORMAT_UYVY";
129 case TBM_FORMAT_VYUY:
130 return "TBM_FORMAT_VYUY";
131 case TBM_FORMAT_AYUV:
132 return "TBM_FORMAT_AYUV";
133 case TBM_FORMAT_NV12:
134 return "TBM_FORMAT_NV12";
135 case TBM_FORMAT_NV21:
136 return "TBM_FORMAT_NV21";
137 case TBM_FORMAT_NV16:
138 return "TBM_FORMAT_NV16";
139 case TBM_FORMAT_NV61:
140 return "TBM_FORMAT_NV61";
141 case TBM_FORMAT_YUV410:
142 return "TBM_FORMAT_YUV410";
143 case TBM_FORMAT_YVU410:
144 return "TBM_FORMAT_YVU410";
145 case TBM_FORMAT_YUV411:
146 return "TBM_FORMAT_YUV411";
147 case TBM_FORMAT_YVU411:
148 return "TBM_FORMAT_YVU411";
149 case TBM_FORMAT_YUV420:
150 return "TBM_FORMAT_YUV420";
151 case TBM_FORMAT_YVU420:
152 return "TBM_FORMAT_YVU420";
153 case TBM_FORMAT_YUV422:
154 return "TBM_FORMAT_YUV422";
155 case TBM_FORMAT_YVU422:
156 return "TBM_FORMAT_YVU422";
157 case TBM_FORMAT_YUV444:
158 return "TBM_FORMAT_YUV444";
159 case TBM_FORMAT_YVU444:
160 return "TBM_FORMAT_YVU444";
161 case TBM_FORMAT_NV12MT:
162 return "TBM_FORMAT_NV12MT";
169 _tbm_surface_mutex_init(void)
171 static bool tbm_surface_mutex_init = false;
173 if (tbm_surface_mutex_init)
176 if (pthread_mutex_init(&tbm_surface_lock, NULL)) {
177 TBM_LOG("[libtbm] fail: tbm_surface mutex init\n");
181 tbm_surface_mutex_init = true;
187 _tbm_surface_mutex_lock(void)
189 if (!_tbm_surface_mutex_init())
192 pthread_mutex_lock(&tbm_surface_lock);
196 _tbm_surface_mutex_unlock(void)
198 pthread_mutex_unlock(&tbm_surface_lock);
202 _init_surface_bufmgr(void)
204 g_surface_bufmgr = tbm_bufmgr_init(-1);
208 _deinit_surface_bufmgr(void)
210 if (!g_surface_bufmgr)
213 tbm_bufmgr_deinit(g_surface_bufmgr);
214 g_surface_bufmgr = NULL;
218 _tbm_surface_internal_query_plane_data(tbm_surface_h surface,
219 int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
221 TBM_RETURN_VAL_IF_FAIL(surface, 0);
222 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
224 struct _tbm_surface *surf = (struct _tbm_surface *)surface;
225 struct _tbm_bufmgr *mgr = surf->bufmgr;
228 TBM_RETURN_VAL_IF_FAIL(mgr != NULL, 0);
229 TBM_RETURN_VAL_IF_FAIL(surf->info.width > 0, 0);
230 TBM_RETURN_VAL_IF_FAIL(surf->info.height > 0, 0);
231 TBM_RETURN_VAL_IF_FAIL(surf->info.format > 0, 0);
233 if (!mgr->backend->surface_get_plane_data)
236 ret = mgr->backend->surface_get_plane_data(surf->info.width,
237 surf->info.height, surf->info.format, plane_idx, size, offset, pitch, bo_idx);
245 _tbm_surface_internal_destroy(tbm_surface_h surface)
248 tbm_bufmgr bufmgr = surface->bufmgr;
249 tbm_user_data *old_data = NULL, *tmp = NULL;
251 for (i = 0; i < surface->num_bos; i++) {
252 surface->bos[i]->surface = NULL;
254 tbm_bo_unref(surface->bos[i]);
255 surface->bos[i] = NULL;
258 /* destory the user_data_list */
259 if (!LIST_IS_EMPTY(&surface->user_data_list)) {
260 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &surface->user_data_list, item_link) {
261 TBM_LOG("[tbm_surface:%d] free user_data\n",
263 user_data_delete(old_data);
267 LIST_DEL(&surface->item_link);
272 if (LIST_IS_EMPTY(&bufmgr->surf_list)) {
273 LIST_DELINIT(&bufmgr->surf_list);
274 _deinit_surface_bufmgr();
279 tbm_surface_internal_query_supported_formats(uint32_t **formats,
282 struct _tbm_bufmgr *mgr;
285 _tbm_surface_mutex_lock();
287 if (!g_surface_bufmgr) {
288 _init_surface_bufmgr();
289 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
292 mgr = g_surface_bufmgr;
294 if (!mgr->backend->surface_supported_format) {
295 _tbm_surface_mutex_unlock();
299 ret = mgr->backend->surface_supported_format(formats, num);
301 _tbm_surface_mutex_unlock();
307 tbm_surface_internal_get_num_planes(tbm_format format)
313 case TBM_FORMAT_RGB332:
314 case TBM_FORMAT_BGR233:
315 case TBM_FORMAT_XRGB4444:
316 case TBM_FORMAT_XBGR4444:
317 case TBM_FORMAT_RGBX4444:
318 case TBM_FORMAT_BGRX4444:
319 case TBM_FORMAT_ARGB4444:
320 case TBM_FORMAT_ABGR4444:
321 case TBM_FORMAT_RGBA4444:
322 case TBM_FORMAT_BGRA4444:
323 case TBM_FORMAT_XRGB1555:
324 case TBM_FORMAT_XBGR1555:
325 case TBM_FORMAT_RGBX5551:
326 case TBM_FORMAT_BGRX5551:
327 case TBM_FORMAT_ARGB1555:
328 case TBM_FORMAT_ABGR1555:
329 case TBM_FORMAT_RGBA5551:
330 case TBM_FORMAT_BGRA5551:
331 case TBM_FORMAT_RGB565:
332 case TBM_FORMAT_BGR565:
333 case TBM_FORMAT_RGB888:
334 case TBM_FORMAT_BGR888:
335 case TBM_FORMAT_XRGB8888:
336 case TBM_FORMAT_XBGR8888:
337 case TBM_FORMAT_RGBX8888:
338 case TBM_FORMAT_BGRX8888:
339 case TBM_FORMAT_ARGB8888:
340 case TBM_FORMAT_ABGR8888:
341 case TBM_FORMAT_RGBA8888:
342 case TBM_FORMAT_BGRA8888:
343 case TBM_FORMAT_XRGB2101010:
344 case TBM_FORMAT_XBGR2101010:
345 case TBM_FORMAT_RGBX1010102:
346 case TBM_FORMAT_BGRX1010102:
347 case TBM_FORMAT_ARGB2101010:
348 case TBM_FORMAT_ABGR2101010:
349 case TBM_FORMAT_RGBA1010102:
350 case TBM_FORMAT_BGRA1010102:
351 case TBM_FORMAT_YUYV:
352 case TBM_FORMAT_YVYU:
353 case TBM_FORMAT_UYVY:
354 case TBM_FORMAT_VYUY:
355 case TBM_FORMAT_AYUV:
358 case TBM_FORMAT_NV12:
359 case TBM_FORMAT_NV12MT:
360 case TBM_FORMAT_NV21:
361 case TBM_FORMAT_NV16:
362 case TBM_FORMAT_NV61:
365 case TBM_FORMAT_YUV410:
366 case TBM_FORMAT_YVU410:
367 case TBM_FORMAT_YUV411:
368 case TBM_FORMAT_YVU411:
369 case TBM_FORMAT_YUV420:
370 case TBM_FORMAT_YVU420:
371 case TBM_FORMAT_YUV422:
372 case TBM_FORMAT_YVU422:
373 case TBM_FORMAT_YUV444:
374 case TBM_FORMAT_YVU444:
386 tbm_surface_internal_get_bpp(tbm_format format)
392 case TBM_FORMAT_RGB332:
393 case TBM_FORMAT_BGR233:
396 case TBM_FORMAT_XRGB4444:
397 case TBM_FORMAT_XBGR4444:
398 case TBM_FORMAT_RGBX4444:
399 case TBM_FORMAT_BGRX4444:
400 case TBM_FORMAT_ARGB4444:
401 case TBM_FORMAT_ABGR4444:
402 case TBM_FORMAT_RGBA4444:
403 case TBM_FORMAT_BGRA4444:
404 case TBM_FORMAT_XRGB1555:
405 case TBM_FORMAT_XBGR1555:
406 case TBM_FORMAT_RGBX5551:
407 case TBM_FORMAT_BGRX5551:
408 case TBM_FORMAT_ARGB1555:
409 case TBM_FORMAT_ABGR1555:
410 case TBM_FORMAT_RGBA5551:
411 case TBM_FORMAT_BGRA5551:
412 case TBM_FORMAT_RGB565:
413 case TBM_FORMAT_BGR565:
416 case TBM_FORMAT_RGB888:
417 case TBM_FORMAT_BGR888:
420 case TBM_FORMAT_XRGB8888:
421 case TBM_FORMAT_XBGR8888:
422 case TBM_FORMAT_RGBX8888:
423 case TBM_FORMAT_BGRX8888:
424 case TBM_FORMAT_ARGB8888:
425 case TBM_FORMAT_ABGR8888:
426 case TBM_FORMAT_RGBA8888:
427 case TBM_FORMAT_BGRA8888:
428 case TBM_FORMAT_XRGB2101010:
429 case TBM_FORMAT_XBGR2101010:
430 case TBM_FORMAT_RGBX1010102:
431 case TBM_FORMAT_BGRX1010102:
432 case TBM_FORMAT_ARGB2101010:
433 case TBM_FORMAT_ABGR2101010:
434 case TBM_FORMAT_RGBA1010102:
435 case TBM_FORMAT_BGRA1010102:
436 case TBM_FORMAT_YUYV:
437 case TBM_FORMAT_YVYU:
438 case TBM_FORMAT_UYVY:
439 case TBM_FORMAT_VYUY:
440 case TBM_FORMAT_AYUV:
443 case TBM_FORMAT_NV12:
444 case TBM_FORMAT_NV12MT:
445 case TBM_FORMAT_NV21:
448 case TBM_FORMAT_NV16:
449 case TBM_FORMAT_NV61:
452 case TBM_FORMAT_YUV410:
453 case TBM_FORMAT_YVU410:
456 case TBM_FORMAT_YUV411:
457 case TBM_FORMAT_YVU411:
458 case TBM_FORMAT_YUV420:
459 case TBM_FORMAT_YVU420:
462 case TBM_FORMAT_YUV422:
463 case TBM_FORMAT_YVU422:
466 case TBM_FORMAT_YUV444:
467 case TBM_FORMAT_YVU444:
478 tbm_surface_internal_create_with_flags(int width, int height,
479 int format, int flags)
481 TBM_RETURN_VAL_IF_FAIL(width > 0, NULL);
482 TBM_RETURN_VAL_IF_FAIL(height > 0, NULL);
484 struct _tbm_bufmgr *mgr;
485 struct _tbm_surface *surf = NULL;
489 uint32_t bo_size = 0;
493 _tbm_surface_mutex_lock();
495 if (!g_surface_bufmgr) {
496 _init_surface_bufmgr();
497 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
500 mgr = g_surface_bufmgr;
501 if (!TBM_BUFMGR_IS_VALID(mgr)) {
502 _tbm_surface_mutex_unlock();
505 surf = calloc(1, sizeof(struct _tbm_surface));
507 _tbm_surface_mutex_unlock();
512 surf->info.width = width;
513 surf->info.height = height;
514 surf->info.format = format;
515 surf->info.bpp = tbm_surface_internal_get_bpp(format);
516 surf->info.num_planes = tbm_surface_internal_get_num_planes(format);
519 /* get size, stride and offset bo_idx */
520 for (i = 0; i < surf->info.num_planes; i++) {
521 _tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride,
523 surf->info.planes[i].size = size;
524 surf->info.planes[i].offset = offset;
525 surf->info.planes[i].stride = stride;
526 surf->planes_bo_idx[i] = bo_idx;
531 for (i = 0; i < surf->info.num_planes; i++) {
532 surf->info.size += surf->info.planes[i].size;
534 if (surf->num_bos -1 > surf->planes_bo_idx[i])
535 surf->num_bos = surf->planes_bo_idx[i]++;
540 for (i = 0; i < surf->num_bos; i++) {
542 for (j = 0; j < surf->info.num_planes; j++) {
543 if (surf->planes_bo_idx[j] == i)
544 bo_size += surf->info.planes[j].size;
546 surf->bos[i] = tbm_bo_alloc(mgr, bo_size, flags);
548 for (j = 0; j < i; j++) {
550 tbm_bo_unref(surf->bos[j]);
556 if (LIST_IS_EMPTY(&mgr->surf_list)) {
557 LIST_DELINIT(&mgr->surf_list);
558 _deinit_surface_bufmgr();
561 _tbm_surface_mutex_unlock();
564 _tbm_bo_set_surface(surf->bos[i], surf);
568 LIST_INITHEAD(&surf->user_data_list);
570 LIST_ADD(&surf->item_link, &mgr->surf_list);
572 _tbm_surface_mutex_unlock();
578 tbm_surface_internal_create_with_bos(tbm_surface_info_s *info,
579 tbm_bo *bos, int num)
581 TBM_RETURN_VAL_IF_FAIL(bos, NULL);
582 TBM_RETURN_VAL_IF_FAIL(info, NULL);
583 TBM_RETURN_VAL_IF_FAIL(num == 1 || info->num_planes == num, NULL);
585 struct _tbm_bufmgr *mgr;
586 struct _tbm_surface *surf = NULL;
589 _tbm_surface_mutex_lock();
591 if (!g_surface_bufmgr) {
592 _init_surface_bufmgr();
593 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
596 mgr = g_surface_bufmgr;
597 if (!TBM_BUFMGR_IS_VALID(mgr)) {
598 _tbm_surface_mutex_unlock();
602 surf = calloc(1, sizeof(struct _tbm_surface));
604 _tbm_surface_mutex_unlock();
609 surf->info.width = info->width;
610 surf->info.height = info->height;
611 surf->info.format = info->format;
612 surf->info.bpp = info->bpp;
613 surf->info.num_planes = info->num_planes;
616 /* get size, stride and offset */
617 for (i = 0; i < info->num_planes; i++) {
618 surf->info.planes[i].offset = info->planes[i].offset;
619 surf->info.planes[i].stride = info->planes[i].stride;
621 if (info->planes[i].size > 0)
622 surf->info.planes[i].size = info->planes[i].size;
624 surf->info.planes[i].size += surf->info.planes[i].stride * info->height;
627 surf->planes_bo_idx[i] = 0;
629 surf->planes_bo_idx[i] = i;
632 if (info->size > 0) {
633 surf->info.size = info->size;
636 for (i = 0; i < info->num_planes; i++)
637 surf->info.size += surf->info.planes[i].size;
640 surf->flags = TBM_BO_DEFAULT;
642 /* create only one bo */
644 for (i = 0; i < num; i++) {
648 surf->bos[i] = tbm_bo_ref(bos[i]);
649 _tbm_bo_set_surface(bos[i], surf);
652 LIST_INITHEAD(&surf->user_data_list);
654 LIST_ADD(&surf->item_link, &mgr->surf_list);
656 _tbm_surface_mutex_unlock();
660 for (i = 0; i < num; i++) {
662 tbm_bo_unref(surf->bos[i]);
670 if (LIST_IS_EMPTY(&g_surface_bufmgr->surf_list)) {
671 LIST_DELINIT(&g_surface_bufmgr->surf_list);
672 _deinit_surface_bufmgr();
675 _tbm_surface_mutex_unlock();
681 tbm_surface_internal_destroy(tbm_surface_h surface)
686 _tbm_surface_mutex_lock();
690 if (surface->refcnt > 0) {
691 _tbm_surface_mutex_unlock();
695 if (surface->refcnt == 0)
696 _tbm_surface_internal_destroy(surface);
698 _tbm_surface_mutex_unlock();
702 tbm_surface_internal_ref(tbm_surface_h surface)
704 TBM_RETURN_IF_FAIL(surface);
706 _tbm_surface_mutex_lock();
710 _tbm_surface_mutex_unlock();
714 tbm_surface_internal_unref(tbm_surface_h surface)
716 TBM_RETURN_IF_FAIL(surface);
718 _tbm_surface_mutex_lock();
722 if (surface->refcnt > 0) {
723 _tbm_surface_mutex_unlock();
727 if (surface->refcnt == 0)
728 _tbm_surface_internal_destroy(surface);
730 _tbm_surface_mutex_unlock();
734 tbm_surface_internal_get_num_bos(tbm_surface_h surface)
736 TBM_RETURN_VAL_IF_FAIL(surface, 0);
738 struct _tbm_surface *surf;
741 _tbm_surface_mutex_lock();
743 surf = (struct _tbm_surface *)surface;
746 _tbm_surface_mutex_unlock();
752 tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx)
754 TBM_RETURN_VAL_IF_FAIL(surface, NULL);
755 TBM_RETURN_VAL_IF_FAIL(bo_idx > -1, NULL);
757 struct _tbm_surface *surf;
760 _tbm_surface_mutex_lock();
762 surf = (struct _tbm_surface *)surface;
763 bo = surf->bos[bo_idx];
765 _tbm_surface_mutex_unlock();
771 tbm_surface_internal_get_size(tbm_surface_h surface)
773 TBM_RETURN_VAL_IF_FAIL(surface, 0);
775 struct _tbm_surface *surf;
778 _tbm_surface_mutex_lock();
780 surf = (struct _tbm_surface *)surface;
781 size = surf->info.size;
783 _tbm_surface_mutex_unlock();
789 tbm_surface_internal_get_plane_data(tbm_surface_h surface, int plane_idx,
790 uint32_t *size, uint32_t *offset, uint32_t *pitch)
792 TBM_RETURN_VAL_IF_FAIL(surface, 0);
793 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
795 struct _tbm_surface *surf;
797 _tbm_surface_mutex_lock();
799 surf = (struct _tbm_surface *)surface;
801 if (plane_idx >= surf->info.num_planes) {
802 _tbm_surface_mutex_unlock();
807 *size = surf->info.planes[plane_idx].size;
810 *offset = surf->info.planes[plane_idx].offset;
813 *pitch = surf->info.planes[plane_idx].stride;
815 _tbm_surface_mutex_unlock();
821 tbm_surface_internal_get_info(tbm_surface_h surface, int opt,
822 tbm_surface_info_s *info, int map)
824 struct _tbm_surface *surf;
825 tbm_bo_handle bo_handles[4];
828 _tbm_surface_mutex_lock();
830 memset(bo_handles, 0, sizeof(tbm_bo_handle) * 4);
832 surf = (struct _tbm_surface *)surface;
834 memset(info, 0x00, sizeof(tbm_surface_info_s));
835 info->width = surf->info.width;
836 info->height = surf->info.height;
837 info->format = surf->info.format;
838 info->bpp = surf->info.bpp;
839 info->size = surf->info.size;
840 info->num_planes = surf->info.num_planes;
843 for (i = 0; i < surf->num_bos; i++) {
844 bo_handles[i] = tbm_bo_map(surf->bos[i], TBM_DEVICE_CPU, opt);
845 if (bo_handles[i].ptr == NULL) {
846 for (j = 0; j < i; j++)
847 tbm_bo_unmap(surf->bos[j]);
849 _tbm_surface_mutex_unlock();
854 for (i = 0; i < surf->num_bos; i++)
855 bo_handles[i] = tbm_bo_get_handle(surf->bos[i], TBM_DEVICE_CPU);
858 for (i = 0; i < surf->info.num_planes; i++) {
859 info->planes[i].size = surf->info.planes[i].size;
860 info->planes[i].offset = surf->info.planes[i].offset;
861 info->planes[i].stride = surf->info.planes[i].stride;
863 if (bo_handles[surf->planes_bo_idx[i]].ptr)
864 info->planes[i].ptr = bo_handles[surf->planes_bo_idx[i]].ptr +
865 surf->info.planes[i].offset;
868 _tbm_surface_mutex_unlock();
874 tbm_surface_internal_unmap(tbm_surface_h surface)
876 struct _tbm_surface *surf;
879 _tbm_surface_mutex_lock();
881 surf = (struct _tbm_surface *)surface;
883 for (i = 0; i < surf->num_bos; i++)
884 tbm_bo_unmap(surf->bos[i]);
886 _tbm_surface_mutex_unlock();
890 tbm_surface_internal_get_width(tbm_surface_h surface)
892 struct _tbm_surface *surf;
895 _tbm_surface_mutex_lock();
897 surf = (struct _tbm_surface *)surface;
898 width = surf->info.width;
900 _tbm_surface_mutex_unlock();
906 tbm_surface_internal_get_height(tbm_surface_h surface)
908 struct _tbm_surface *surf;
911 _tbm_surface_mutex_lock();
913 surf = (struct _tbm_surface *)surface;
914 height = surf->info.height;
916 _tbm_surface_mutex_unlock();
923 tbm_surface_internal_get_format(tbm_surface_h surface)
925 struct _tbm_surface *surf;
928 _tbm_surface_mutex_lock();
930 surf = (struct _tbm_surface *)surface;
931 format = surf->info.format;
933 _tbm_surface_mutex_unlock();
939 tbm_surface_internal_get_plane_bo_idx(tbm_surface_h surface, int plane_idx)
941 TBM_RETURN_VAL_IF_FAIL(surface, 0);
942 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
943 struct _tbm_surface *surf;
946 _tbm_surface_mutex_lock();
948 surf = (struct _tbm_surface *)surface;
949 bo_idx = surf->planes_bo_idx[plane_idx];
951 _tbm_surface_mutex_unlock();
957 _tbm_surface_internal_get_debug_pid(tbm_surface_h surface)
959 TBM_RETURN_VAL_IF_FAIL(surface, 0);
961 return surface->debug_pid;
965 tbm_surface_internal_set_debug_pid(tbm_surface_h surface, unsigned int pid)
967 TBM_RETURN_IF_FAIL(surface);
969 surface->debug_pid = pid;
973 tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key,
974 tbm_data_free data_free_func)
976 TBM_RETURN_VAL_IF_FAIL(surface, 0);
980 /* check if the data according to the key exist if so, return false. */
981 data = user_data_lookup(&surface->user_data_list, key);
983 TBM_LOG("[libtbm:%d] "
984 "waring: %s:%d user data already exist. key:%ld\n",
985 getpid(), __func__, __LINE__, key);
989 data = user_data_create(key, data_free_func);
993 LIST_ADD(&data->item_link, &surface->user_data_list);
999 tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key,
1002 TBM_RETURN_VAL_IF_FAIL(surface, 0);
1004 tbm_user_data *old_data;
1006 if (LIST_IS_EMPTY(&surface->user_data_list))
1009 old_data = user_data_lookup(&surface->user_data_list, key);
1013 if (old_data->data && old_data->free_func)
1014 old_data->free_func(old_data->data);
1016 old_data->data = data;
1022 tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key,
1025 TBM_RETURN_VAL_IF_FAIL(surface, 0);
1027 tbm_user_data *old_data;
1029 if (!data || LIST_IS_EMPTY(&surface->user_data_list))
1032 old_data = user_data_lookup(&surface->user_data_list, key);
1038 *data = old_data->data;
1044 tbm_surface_internal_delete_user_data(tbm_surface_h surface,
1047 TBM_RETURN_VAL_IF_FAIL(surface, 0);
1049 tbm_user_data *old_data = (void *)0;
1051 if (LIST_IS_EMPTY(&surface->user_data_list))
1054 old_data = user_data_lookup(&surface->user_data_list, key);
1058 user_data_delete(old_data);