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 = NULL;
39 static pthread_mutex_t tbm_surface_lock;
41 char* _tbm_surface_internal_format_to_str(tbm_format format)
45 case TBM_FORMAT_C8 : return "TBM_FORMAT_C8";
46 case TBM_FORMAT_RGB332 : return "TBM_FORMAT_RGB332";
47 case TBM_FORMAT_BGR233 : return "TBM_FORMAT_BGR233";
48 case TBM_FORMAT_XRGB4444 : return "TBM_FORMAT_XRGB4444";
49 case TBM_FORMAT_XBGR4444 : return "TBM_FORMAT_XBGR4444";
50 case TBM_FORMAT_RGBX4444 : return "TBM_FORMAT_RGBX4444";
51 case TBM_FORMAT_BGRX4444 : return "TBM_FORMAT_BGRX4444";
52 case TBM_FORMAT_ARGB4444 : return "TBM_FORMAT_ARGB4444";
53 case TBM_FORMAT_ABGR4444 : return "TBM_FORMAT_ABGR4444";
54 case TBM_FORMAT_RGBA4444 : return "TBM_FORMAT_RGBA4444";
55 case TBM_FORMAT_BGRA4444 : return "TBM_FORMAT_BGRA4444";
56 case TBM_FORMAT_XRGB1555 : return "TBM_FORMAT_XRGB1555";
57 case TBM_FORMAT_XBGR1555 : return "TBM_FORMAT_XBGR1555";
58 case TBM_FORMAT_RGBX5551 : return "TBM_FORMAT_RGBX5551";
59 case TBM_FORMAT_BGRX5551 : return "TBM_FORMAT_BGRX5551";
60 case TBM_FORMAT_ARGB1555 : return "TBM_FORMAT_ARGB1555";
61 case TBM_FORMAT_ABGR1555 : return "TBM_FORMAT_ABGR1555";
62 case TBM_FORMAT_RGBA5551 : return "TBM_FORMAT_RGBA5551";
63 case TBM_FORMAT_BGRA5551 : return "TBM_FORMAT_BGRA5551";
64 case TBM_FORMAT_RGB565 : return "TBM_FORMAT_RGB565";
65 case TBM_FORMAT_BGR565 : return "TBM_FORMAT_BGR565";
66 case TBM_FORMAT_RGB888 : return "TBM_FORMAT_RGB888";
67 case TBM_FORMAT_BGR888 : return "TBM_FORMAT_BGR888";
68 case TBM_FORMAT_XRGB8888 : return "TBM_FORMAT_XRGB8888";
69 case TBM_FORMAT_XBGR8888 : return "TBM_FORMAT_XBGR8888";
70 case TBM_FORMAT_RGBX8888 : return "TBM_FORMAT_RGBX8888";
71 case TBM_FORMAT_BGRX8888 : return "TBM_FORMAT_BGRX8888";
72 case TBM_FORMAT_ARGB8888 : return "TBM_FORMAT_ARGB8888";
73 case TBM_FORMAT_ABGR8888 : return "TBM_FORMAT_ABGR8888";
74 case TBM_FORMAT_RGBA8888 : return "TBM_FORMAT_RGBA8888";
75 case TBM_FORMAT_BGRA8888 : return "TBM_FORMAT_BGRA8888";
76 case TBM_FORMAT_XRGB2101010 : return "TBM_FORMAT_XRGB2101010";
77 case TBM_FORMAT_XBGR2101010 : return "TBM_FORMAT_XBGR2101010";
78 case TBM_FORMAT_RGBX1010102 : return "TBM_FORMAT_RGBX1010102";
79 case TBM_FORMAT_BGRX1010102 : return "TBM_FORMAT_BGRX1010102";
80 case TBM_FORMAT_ARGB2101010 : return "TBM_FORMAT_ARGB2101010";
81 case TBM_FORMAT_ABGR2101010 : return "TBM_FORMAT_ABGR2101010";
82 case TBM_FORMAT_RGBA1010102 : return "TBM_FORMAT_RGBA1010102";
83 case TBM_FORMAT_BGRA1010102 : return "TBM_FORMAT_BGRA1010102";
84 case TBM_FORMAT_YUYV : return "TBM_FORMAT_YUYV";
85 case TBM_FORMAT_YVYU : return "TBM_FORMAT_YVYU";
86 case TBM_FORMAT_UYVY : return "TBM_FORMAT_UYVY";
87 case TBM_FORMAT_VYUY : return "TBM_FORMAT_VYUY";
88 case TBM_FORMAT_AYUV : return "TBM_FORMAT_AYUV";
89 case TBM_FORMAT_NV12 : return "TBM_FORMAT_NV12";
90 case TBM_FORMAT_NV21 : return "TBM_FORMAT_NV21";
91 case TBM_FORMAT_NV16 : return "TBM_FORMAT_NV16";
92 case TBM_FORMAT_NV61 : return "TBM_FORMAT_NV61";
93 case TBM_FORMAT_YUV410 : return "TBM_FORMAT_YUV410";
94 case TBM_FORMAT_YVU410 : return "TBM_FORMAT_YVU410";
95 case TBM_FORMAT_YUV411 : return "TBM_FORMAT_YUV411";
96 case TBM_FORMAT_YVU411 : return "TBM_FORMAT_YVU411";
97 case TBM_FORMAT_YUV420 : return "TBM_FORMAT_YUV420";
98 case TBM_FORMAT_YVU420 : return "TBM_FORMAT_YVU420";
99 case TBM_FORMAT_YUV422 : return "TBM_FORMAT_YUV422";
100 case TBM_FORMAT_YVU422 : return "TBM_FORMAT_YVU422";
101 case TBM_FORMAT_YUV444 : return "TBM_FORMAT_YUV444";
102 case TBM_FORMAT_YVU444 : return "TBM_FORMAT_YVU444";
103 case TBM_FORMAT_NV12MT : return "TBM_FORMAT_NV12MT";
104 default : return "unknwon";
110 _tbm_surface_mutex_init (void)
112 static bool tbm_surface_mutex_init = false;
114 if (tbm_surface_mutex_init)
117 if (pthread_mutex_init (&tbm_surface_lock, NULL))
119 TBM_LOG ("[libtbm] fail: tbm_surface mutex init\n");
123 tbm_surface_mutex_init = true;
129 _tbm_surface_mutex_lock (void)
131 if (!_tbm_surface_mutex_init ())
134 pthread_mutex_lock (&tbm_surface_lock);
138 _tbm_surface_mutex_unlock (void)
140 pthread_mutex_unlock (&tbm_surface_lock);
144 _init_surface_bufmgr()
146 g_surface_bufmgr = tbm_bufmgr_init (-1);
150 _deinit_surface_bufmgr()
152 if (!g_surface_bufmgr)
155 tbm_bufmgr_deinit (g_surface_bufmgr);
156 g_surface_bufmgr = NULL;
160 _tbm_surface_internal_query_size (tbm_surface_h surface)
162 TBM_RETURN_VAL_IF_FAIL (surface, 0);
164 struct _tbm_surface *surf = (struct _tbm_surface *) surface;
165 struct _tbm_bufmgr *mgr = surf->bufmgr;
168 TBM_RETURN_VAL_IF_FAIL (mgr != NULL, 0);
169 TBM_RETURN_VAL_IF_FAIL (surf->info.width > 0, 0);
170 TBM_RETURN_VAL_IF_FAIL (surf->info.height > 0, 0);
171 TBM_RETURN_VAL_IF_FAIL (surf->info.format > 0, 0);
173 if (!mgr->backend->surface_get_size)
176 size = mgr->backend->surface_get_size (surf, surf->info.width, surf->info.height, surf->info.format);
182 _tbm_surface_internal_query_plane_data (tbm_surface_h surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
184 TBM_RETURN_VAL_IF_FAIL (surface, 0);
185 TBM_RETURN_VAL_IF_FAIL (plane_idx > -1, 0);
187 struct _tbm_surface *surf = (struct _tbm_surface *) surface;
188 struct _tbm_bufmgr *mgr = surf->bufmgr;
191 TBM_RETURN_VAL_IF_FAIL (mgr != NULL, 0);
192 TBM_RETURN_VAL_IF_FAIL (surf->info.width > 0, 0);
193 TBM_RETURN_VAL_IF_FAIL (surf->info.height > 0, 0);
194 TBM_RETURN_VAL_IF_FAIL (surf->info.format > 0, 0);
196 if (!mgr->backend->surface_get_plane_data)
199 ret = mgr->backend->surface_get_plane_data (surf, surf->info.width, surf->info.height, surf->info.format, plane_idx, size, offset, pitch, bo_idx);
207 _tbm_surface_internal_query_num_bos (tbm_format format)
209 TBM_RETURN_VAL_IF_FAIL (format > 0, 0);
210 struct _tbm_bufmgr *mgr;
213 mgr = g_surface_bufmgr;
215 if (!mgr->backend->surface_get_num_bos)
218 ret = mgr->backend->surface_get_num_bos (format);
226 _tbm_surface_internal_destroy (tbm_surface_h surface)
229 tbm_bufmgr bufmgr = surface->bufmgr;
231 for (i = 0; i < surface->num_bos; i++)
233 surface->bos[i]->surface = NULL;
235 tbm_bo_unref (surface->bos[i]);
236 surface->bos[i] = NULL;
239 LIST_DEL (&surface->item_link);
244 if(LIST_IS_EMPTY (&bufmgr->surf_list))
246 LIST_DELINIT (&bufmgr->surf_list);
247 _deinit_surface_bufmgr ();
254 tbm_surface_internal_query_supported_formats (uint32_t **formats, uint32_t *num)
256 struct _tbm_bufmgr *mgr;
259 _tbm_surface_mutex_lock();
261 if (!g_surface_bufmgr)
263 _init_surface_bufmgr();
264 LIST_INITHEAD (&g_surface_bufmgr->surf_list);
267 mgr = g_surface_bufmgr;
269 if (!mgr->backend->surface_supported_format)
271 _tbm_surface_mutex_unlock();
275 ret = mgr->backend->surface_supported_format (formats, num);
277 _tbm_surface_mutex_unlock();
283 int tbm_surface_internal_get_num_planes (tbm_format format)
290 case TBM_FORMAT_RGB332:
291 case TBM_FORMAT_BGR233:
292 case TBM_FORMAT_XRGB4444:
293 case TBM_FORMAT_XBGR4444:
294 case TBM_FORMAT_RGBX4444:
295 case TBM_FORMAT_BGRX4444:
296 case TBM_FORMAT_ARGB4444:
297 case TBM_FORMAT_ABGR4444:
298 case TBM_FORMAT_RGBA4444:
299 case TBM_FORMAT_BGRA4444:
300 case TBM_FORMAT_XRGB1555:
301 case TBM_FORMAT_XBGR1555:
302 case TBM_FORMAT_RGBX5551:
303 case TBM_FORMAT_BGRX5551:
304 case TBM_FORMAT_ARGB1555:
305 case TBM_FORMAT_ABGR1555:
306 case TBM_FORMAT_RGBA5551:
307 case TBM_FORMAT_BGRA5551:
308 case TBM_FORMAT_RGB565:
309 case TBM_FORMAT_BGR565:
310 case TBM_FORMAT_RGB888:
311 case TBM_FORMAT_BGR888:
312 case TBM_FORMAT_XRGB8888:
313 case TBM_FORMAT_XBGR8888:
314 case TBM_FORMAT_RGBX8888:
315 case TBM_FORMAT_BGRX8888:
316 case TBM_FORMAT_ARGB8888:
317 case TBM_FORMAT_ABGR8888:
318 case TBM_FORMAT_RGBA8888:
319 case TBM_FORMAT_BGRA8888:
320 case TBM_FORMAT_XRGB2101010:
321 case TBM_FORMAT_XBGR2101010:
322 case TBM_FORMAT_RGBX1010102:
323 case TBM_FORMAT_BGRX1010102:
324 case TBM_FORMAT_ARGB2101010:
325 case TBM_FORMAT_ABGR2101010:
326 case TBM_FORMAT_RGBA1010102:
327 case TBM_FORMAT_BGRA1010102:
328 case TBM_FORMAT_YUYV:
329 case TBM_FORMAT_YVYU:
330 case TBM_FORMAT_UYVY:
331 case TBM_FORMAT_VYUY:
332 case TBM_FORMAT_AYUV:
335 case TBM_FORMAT_NV12:
336 case TBM_FORMAT_NV21:
337 case TBM_FORMAT_NV16:
338 case TBM_FORMAT_NV61:
341 case TBM_FORMAT_YUV410:
342 case TBM_FORMAT_YVU410:
343 case TBM_FORMAT_YUV411:
344 case TBM_FORMAT_YVU411:
345 case TBM_FORMAT_YUV420:
346 case TBM_FORMAT_YVU420:
347 case TBM_FORMAT_YUV422:
348 case TBM_FORMAT_YVU422:
349 case TBM_FORMAT_YUV444:
350 case TBM_FORMAT_YVU444:
361 int tbm_surface_internal_get_bpp (tbm_format format)
368 case TBM_FORMAT_RGB332:
369 case TBM_FORMAT_BGR233:
372 case TBM_FORMAT_XRGB4444:
373 case TBM_FORMAT_XBGR4444:
374 case TBM_FORMAT_RGBX4444:
375 case TBM_FORMAT_BGRX4444:
376 case TBM_FORMAT_ARGB4444:
377 case TBM_FORMAT_ABGR4444:
378 case TBM_FORMAT_RGBA4444:
379 case TBM_FORMAT_BGRA4444:
380 case TBM_FORMAT_XRGB1555:
381 case TBM_FORMAT_XBGR1555:
382 case TBM_FORMAT_RGBX5551:
383 case TBM_FORMAT_BGRX5551:
384 case TBM_FORMAT_ARGB1555:
385 case TBM_FORMAT_ABGR1555:
386 case TBM_FORMAT_RGBA5551:
387 case TBM_FORMAT_BGRA5551:
388 case TBM_FORMAT_RGB565:
389 case TBM_FORMAT_BGR565:
392 case TBM_FORMAT_RGB888:
393 case TBM_FORMAT_BGR888:
396 case TBM_FORMAT_XRGB8888:
397 case TBM_FORMAT_XBGR8888:
398 case TBM_FORMAT_RGBX8888:
399 case TBM_FORMAT_BGRX8888:
400 case TBM_FORMAT_ARGB8888:
401 case TBM_FORMAT_ABGR8888:
402 case TBM_FORMAT_RGBA8888:
403 case TBM_FORMAT_BGRA8888:
404 case TBM_FORMAT_XRGB2101010:
405 case TBM_FORMAT_XBGR2101010:
406 case TBM_FORMAT_RGBX1010102:
407 case TBM_FORMAT_BGRX1010102:
408 case TBM_FORMAT_ARGB2101010:
409 case TBM_FORMAT_ABGR2101010:
410 case TBM_FORMAT_RGBA1010102:
411 case TBM_FORMAT_BGRA1010102:
412 case TBM_FORMAT_YUYV:
413 case TBM_FORMAT_YVYU:
414 case TBM_FORMAT_UYVY:
415 case TBM_FORMAT_VYUY:
416 case TBM_FORMAT_AYUV:
419 case TBM_FORMAT_NV12:
420 case TBM_FORMAT_NV21:
423 case TBM_FORMAT_NV16:
424 case TBM_FORMAT_NV61:
427 case TBM_FORMAT_YUV410:
428 case TBM_FORMAT_YVU410:
431 case TBM_FORMAT_YUV411:
432 case TBM_FORMAT_YVU411:
433 case TBM_FORMAT_YUV420:
434 case TBM_FORMAT_YVU420:
437 case TBM_FORMAT_YUV422:
438 case TBM_FORMAT_YVU422:
441 case TBM_FORMAT_YUV444:
442 case TBM_FORMAT_YVU444:
453 tbm_surface_internal_create_with_flags (int width, int height, int format, int flags)
455 TBM_RETURN_VAL_IF_FAIL (width > 0, NULL);
456 TBM_RETURN_VAL_IF_FAIL (height > 0, NULL);
458 struct _tbm_bufmgr *mgr;
459 struct _tbm_surface *surf = NULL;
463 uint32_t bo_size = 0;
467 _tbm_surface_mutex_lock();
469 if (!g_surface_bufmgr)
471 _init_surface_bufmgr();
472 LIST_INITHEAD (&g_surface_bufmgr->surf_list);
475 mgr = g_surface_bufmgr;
476 if (!TBM_BUFMGR_IS_VALID(mgr))
478 _tbm_surface_mutex_unlock();
481 surf = calloc (1, sizeof(struct _tbm_surface));
484 _tbm_surface_mutex_unlock();
489 surf->info.width = width;
490 surf->info.height = height;
491 surf->info.format = format;
492 surf->info.bpp = tbm_surface_internal_get_bpp (format);
493 surf->info.size = _tbm_surface_internal_query_size (surf);
494 surf->info.num_planes = tbm_surface_internal_get_num_planes(format);
495 surf->num_bos = _tbm_surface_internal_query_num_bos(format);
498 /* get size, stride and offset bo_idx*/
499 for (i = 0; i < surf->info.num_planes; i++)
501 _tbm_surface_internal_query_plane_data (surf, i, &size, &offset, &stride, &bo_idx);
502 surf->info.planes[i].size = size;
503 surf->info.planes[i].offset = offset;
504 surf->info.planes[i].stride = stride;
505 surf->planes_bo_idx[i] = bo_idx;
510 for (i = 0; i < surf->num_bos; i++)
513 for (j = 0; j < surf->info.num_planes; j++)
515 if (surf->planes_bo_idx[j] == i)
516 bo_size += surf->info.planes[j].size;
518 surf->bos[i] = tbm_bo_alloc (mgr, bo_size, flags);
520 for (j = 0; j < i; j++)
521 tbm_bo_unref (surf->bos[j]);
526 if(LIST_IS_EMPTY (&mgr->surf_list))
528 LIST_DELINIT (&mgr->surf_list);
529 _deinit_surface_bufmgr ();
532 _tbm_surface_mutex_unlock();
535 _tbm_bo_set_surface(surf->bos[i], surf);
539 LIST_ADD (&surf->item_link, &mgr->surf_list);
541 _tbm_surface_mutex_unlock();
547 tbm_surface_internal_create_with_bos (tbm_surface_info_s *info, tbm_bo *bos, int num)
549 TBM_RETURN_VAL_IF_FAIL (bos, NULL);
550 TBM_RETURN_VAL_IF_FAIL (info, NULL);
551 TBM_RETURN_VAL_IF_FAIL (num == 1 || info->num_planes == num, NULL);
553 struct _tbm_bufmgr *mgr;
554 struct _tbm_surface *surf = NULL;
557 _tbm_surface_mutex_lock();
559 if (!g_surface_bufmgr)
561 _init_surface_bufmgr();
562 LIST_INITHEAD (&g_surface_bufmgr->surf_list);
565 mgr = g_surface_bufmgr;
566 if (!TBM_BUFMGR_IS_VALID(mgr))
568 _tbm_surface_mutex_unlock();
572 surf = calloc (1, sizeof(struct _tbm_surface));
575 _tbm_surface_mutex_unlock();
580 surf->info.width = info->width;
581 surf->info.height = info->height;
582 surf->info.format = info->format;
583 surf->info.bpp = info->bpp;
584 surf->info.num_planes = info->num_planes;
587 /* get size, stride and offset */
588 for (i = 0; i < info->num_planes; i++)
590 surf->info.planes[i].offset = info->planes[i].offset;
591 surf->info.planes[i].stride = info->planes[i].stride;
593 if (info->planes[i].size > 0)
594 surf->info.planes[i].size = info->planes[i].size;
596 surf->info.planes[i].size += surf->info.planes[i].stride * info->height;
599 surf->planes_bo_idx[i] = 0;
601 surf->planes_bo_idx[i] = i;
606 surf->info.size = info->size;
611 for (i = 0; i < info->num_planes; i++)
613 surf->info.size += surf->info.planes[i].size;
617 surf->flags = TBM_BO_DEFAULT;
619 /* create only one bo */
621 for (i = 0; i < num; i++)
626 surf->bos[i] = tbm_bo_ref(bos[i]);
627 _tbm_bo_set_surface(bos[i], surf);
630 LIST_ADD (&surf->item_link, &mgr->surf_list);
632 _tbm_surface_mutex_unlock();
636 for (i = 0; i < num; i++)
640 tbm_bo_unref (surf->bos[i]);
648 if(LIST_IS_EMPTY (&g_surface_bufmgr->surf_list))
650 LIST_DELINIT (&g_surface_bufmgr->surf_list);
651 _deinit_surface_bufmgr ();
654 _tbm_surface_mutex_unlock();
661 tbm_surface_internal_destroy (tbm_surface_h surface)
666 _tbm_surface_mutex_lock();
670 if (surface->refcnt > 0) {
671 _tbm_surface_mutex_unlock();
675 if (surface->refcnt == 0)
676 _tbm_surface_internal_destroy(surface);
678 _tbm_surface_mutex_unlock();
683 tbm_surface_internal_ref (tbm_surface_h surface)
685 TBM_RETURN_IF_FAIL (surface);
687 _tbm_surface_mutex_lock();
691 _tbm_surface_mutex_unlock();
695 tbm_surface_internal_unref (tbm_surface_h surface)
697 TBM_RETURN_IF_FAIL (surface);
699 _tbm_surface_mutex_lock();
703 if (surface->refcnt > 0) {
704 _tbm_surface_mutex_unlock();
708 if (surface->refcnt == 0)
709 _tbm_surface_internal_destroy(surface);
711 _tbm_surface_mutex_unlock();
715 tbm_surface_internal_get_num_bos (tbm_surface_h surface)
717 TBM_RETURN_VAL_IF_FAIL (surface, 0);
719 struct _tbm_surface *surf;
722 _tbm_surface_mutex_lock();
724 surf = (struct _tbm_surface *) surface;
727 _tbm_surface_mutex_unlock();
733 tbm_surface_internal_get_bo (tbm_surface_h surface, int bo_idx)
735 TBM_RETURN_VAL_IF_FAIL (surface, NULL);
736 TBM_RETURN_VAL_IF_FAIL (bo_idx > -1, NULL);
738 struct _tbm_surface *surf;
741 _tbm_surface_mutex_lock();
743 surf = (struct _tbm_surface *) surface;
744 bo = surf->bos[bo_idx];
746 _tbm_surface_mutex_unlock();
752 tbm_surface_internal_get_size (tbm_surface_h surface)
754 TBM_RETURN_VAL_IF_FAIL (surface, 0);
756 struct _tbm_surface *surf;
759 _tbm_surface_mutex_lock();
761 surf = (struct _tbm_surface *) surface;
762 size = surf->info.size;
764 _tbm_surface_mutex_unlock();
770 tbm_surface_internal_get_plane_data (tbm_surface_h surface, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch)
772 TBM_RETURN_VAL_IF_FAIL (surface, 0);
773 TBM_RETURN_VAL_IF_FAIL (plane_idx > -1, 0);
775 struct _tbm_surface *surf;
777 _tbm_surface_mutex_lock();
779 surf = (struct _tbm_surface *) surface;
781 if (plane_idx >= surf->info.num_planes)
783 _tbm_surface_mutex_unlock();
787 *size = surf->info.planes[plane_idx].size;
788 *offset = surf->info.planes[plane_idx].offset;
789 *pitch = surf->info.planes[plane_idx].stride;
791 _tbm_surface_mutex_unlock();
797 tbm_surface_internal_get_info (tbm_surface_h surface, int opt, tbm_surface_info_s *info, int map)
799 struct _tbm_surface *surf;
800 tbm_bo_handle bo_handles[4];
803 _tbm_surface_mutex_lock();
805 memset (bo_handles, 0, sizeof(tbm_bo_handle) * 4);
807 surf = (struct _tbm_surface *)surface;
809 info->width = surf->info.width;
810 info->height = surf->info.height;
811 info->format = surf->info.format;
812 info->bpp = surf->info.bpp;
813 info->size = surf->info.size;
814 info->num_planes = surf->info.num_planes;
818 for (i = 0; i < surf->num_bos; i++)
820 bo_handles[i] = tbm_bo_map (surf->bos[i], TBM_DEVICE_CPU, opt);
821 if (bo_handles[i].ptr == NULL)
823 for (j = 0; j < i; j++)
824 tbm_bo_unmap (surf->bos[j]);
826 _tbm_surface_mutex_unlock();
833 for (i = 0; i < surf->num_bos; i++)
835 bo_handles[i] = tbm_bo_get_handle (surf->bos[i], TBM_DEVICE_CPU);
836 if (bo_handles[i].ptr == NULL)
838 _tbm_surface_mutex_unlock();
844 for (i = 0; i < surf->info.num_planes; i++)
846 info->planes[i].size = surf->info.planes[i].size;
847 info->planes[i].offset = surf->info.planes[i].offset;
848 info->planes[i].stride = surf->info.planes[i].stride;
849 info->planes[i].ptr = bo_handles[surf->planes_bo_idx[i]].ptr + surf->info.planes[i].offset;
852 _tbm_surface_mutex_unlock();
858 tbm_surface_internal_unmap (tbm_surface_h surface)
860 struct _tbm_surface *surf;
863 _tbm_surface_mutex_lock();
865 surf = (struct _tbm_surface *)surface;
867 for (i = 0; i < surf->num_bos; i++)
868 tbm_bo_unmap (surf->bos[i]);
870 _tbm_surface_mutex_unlock();
874 tbm_surface_internal_get_width (tbm_surface_h surface)
876 struct _tbm_surface *surf;
879 _tbm_surface_mutex_lock();
881 surf = (struct _tbm_surface *)surface;
882 width = surf->info.width;
884 _tbm_surface_mutex_unlock();
890 tbm_surface_internal_get_height (tbm_surface_h surface)
892 struct _tbm_surface *surf;
895 _tbm_surface_mutex_lock();
897 surf = (struct _tbm_surface *)surface;
898 height = surf->info.height;
900 _tbm_surface_mutex_unlock();
907 tbm_surface_internal_get_format (tbm_surface_h surface)
909 struct _tbm_surface *surf;
912 _tbm_surface_mutex_lock();
914 surf = (struct _tbm_surface *)surface;
915 format = surf->info.format;
917 _tbm_surface_mutex_unlock();
923 tbm_surface_internal_get_plane_bo_idx (tbm_surface_h surface, int plane_idx)
925 TBM_RETURN_VAL_IF_FAIL (surface, 0);
926 TBM_RETURN_VAL_IF_FAIL (plane_idx > -1, 0);
927 struct _tbm_surface *surf;
930 _tbm_surface_mutex_lock();
932 surf = (struct _tbm_surface *)surface;
933 bo_idx = surf->planes_bo_idx[plane_idx];
935 _tbm_surface_mutex_unlock();