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 **************************************************************************/
36 #include "tbm_bufmgr.h"
37 #include "tbm_bufmgr_int.h"
38 #include "tbm_surface_internal.h"
42 #define C(b, m) (((b) >> (m)) & 0xFF)
43 #define B(c, s) ((((unsigned int)(c)) & 0xff) << (s))
44 #define FOURCC(a, b, c, d) (B(d, 24) | B(c, 16) | B(b, 8) | B(a, 0))
45 #define FOURCC_STR(id) C(id, 0), C(id, 8), C(id, 16), C(id, 24)
46 #define FOURCC_ID(str) FOURCC(((char*)str)[0], ((char*)str)[1], ((char*)str)[2], ((char*)str)[3])
48 static tbm_bufmgr g_surface_bufmgr;
49 static pthread_mutex_t tbm_surface_lock;
54 _get_time_in_millis(void)
58 gettimeofday(&tv, NULL);
60 return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
64 _tbm_surface_internal_format_to_str(tbm_format format)
68 return "TBM_FORMAT_C8";
69 case TBM_FORMAT_RGB332:
70 return "TBM_FORMAT_RGB332";
71 case TBM_FORMAT_BGR233:
72 return "TBM_FORMAT_BGR233";
73 case TBM_FORMAT_XRGB4444:
74 return "TBM_FORMAT_XRGB4444";
75 case TBM_FORMAT_XBGR4444:
76 return "TBM_FORMAT_XBGR4444";
77 case TBM_FORMAT_RGBX4444:
78 return "TBM_FORMAT_RGBX4444";
79 case TBM_FORMAT_BGRX4444:
80 return "TBM_FORMAT_BGRX4444";
81 case TBM_FORMAT_ARGB4444:
82 return "TBM_FORMAT_ARGB4444";
83 case TBM_FORMAT_ABGR4444:
84 return "TBM_FORMAT_ABGR4444";
85 case TBM_FORMAT_RGBA4444:
86 return "TBM_FORMAT_RGBA4444";
87 case TBM_FORMAT_BGRA4444:
88 return "TBM_FORMAT_BGRA4444";
89 case TBM_FORMAT_XRGB1555:
90 return "TBM_FORMAT_XRGB1555";
91 case TBM_FORMAT_XBGR1555:
92 return "TBM_FORMAT_XBGR1555";
93 case TBM_FORMAT_RGBX5551:
94 return "TBM_FORMAT_RGBX5551";
95 case TBM_FORMAT_BGRX5551:
96 return "TBM_FORMAT_BGRX5551";
97 case TBM_FORMAT_ARGB1555:
98 return "TBM_FORMAT_ARGB1555";
99 case TBM_FORMAT_ABGR1555:
100 return "TBM_FORMAT_ABGR1555";
101 case TBM_FORMAT_RGBA5551:
102 return "TBM_FORMAT_RGBA5551";
103 case TBM_FORMAT_BGRA5551:
104 return "TBM_FORMAT_BGRA5551";
105 case TBM_FORMAT_RGB565:
106 return "TBM_FORMAT_RGB565";
107 case TBM_FORMAT_BGR565:
108 return "TBM_FORMAT_BGR565";
109 case TBM_FORMAT_RGB888:
110 return "TBM_FORMAT_RGB888";
111 case TBM_FORMAT_BGR888:
112 return "TBM_FORMAT_BGR888";
113 case TBM_FORMAT_XRGB8888:
114 return "TBM_FORMAT_XRGB8888";
115 case TBM_FORMAT_XBGR8888:
116 return "TBM_FORMAT_XBGR8888";
117 case TBM_FORMAT_RGBX8888:
118 return "TBM_FORMAT_RGBX8888";
119 case TBM_FORMAT_BGRX8888:
120 return "TBM_FORMAT_BGRX8888";
121 case TBM_FORMAT_ARGB8888:
122 return "TBM_FORMAT_ARGB8888";
123 case TBM_FORMAT_ABGR8888:
124 return "TBM_FORMAT_ABGR8888";
125 case TBM_FORMAT_RGBA8888:
126 return "TBM_FORMAT_RGBA8888";
127 case TBM_FORMAT_BGRA8888:
128 return "TBM_FORMAT_BGRA8888";
129 case TBM_FORMAT_XRGB2101010:
130 return "TBM_FORMAT_XRGB2101010";
131 case TBM_FORMAT_XBGR2101010:
132 return "TBM_FORMAT_XBGR2101010";
133 case TBM_FORMAT_RGBX1010102:
134 return "TBM_FORMAT_RGBX1010102";
135 case TBM_FORMAT_BGRX1010102:
136 return "TBM_FORMAT_BGRX1010102";
137 case TBM_FORMAT_ARGB2101010:
138 return "TBM_FORMAT_ARGB2101010";
139 case TBM_FORMAT_ABGR2101010:
140 return "TBM_FORMAT_ABGR2101010";
141 case TBM_FORMAT_RGBA1010102:
142 return "TBM_FORMAT_RGBA1010102";
143 case TBM_FORMAT_BGRA1010102:
144 return "TBM_FORMAT_BGRA1010102";
145 case TBM_FORMAT_YUYV:
146 return "TBM_FORMAT_YUYV";
147 case TBM_FORMAT_YVYU:
148 return "TBM_FORMAT_YVYU";
149 case TBM_FORMAT_UYVY:
150 return "TBM_FORMAT_UYVY";
151 case TBM_FORMAT_VYUY:
152 return "TBM_FORMAT_VYUY";
153 case TBM_FORMAT_AYUV:
154 return "TBM_FORMAT_AYUV";
155 case TBM_FORMAT_NV12:
156 return "TBM_FORMAT_NV12";
157 case TBM_FORMAT_NV21:
158 return "TBM_FORMAT_NV21";
159 case TBM_FORMAT_NV16:
160 return "TBM_FORMAT_NV16";
161 case TBM_FORMAT_NV61:
162 return "TBM_FORMAT_NV61";
163 case TBM_FORMAT_YUV410:
164 return "TBM_FORMAT_YUV410";
165 case TBM_FORMAT_YVU410:
166 return "TBM_FORMAT_YVU410";
167 case TBM_FORMAT_YUV411:
168 return "TBM_FORMAT_YUV411";
169 case TBM_FORMAT_YVU411:
170 return "TBM_FORMAT_YVU411";
171 case TBM_FORMAT_YUV420:
172 return "TBM_FORMAT_YUV420";
173 case TBM_FORMAT_YVU420:
174 return "TBM_FORMAT_YVU420";
175 case TBM_FORMAT_YUV422:
176 return "TBM_FORMAT_YUV422";
177 case TBM_FORMAT_YVU422:
178 return "TBM_FORMAT_YVU422";
179 case TBM_FORMAT_YUV444:
180 return "TBM_FORMAT_YUV444";
181 case TBM_FORMAT_YVU444:
182 return "TBM_FORMAT_YVU444";
183 case TBM_FORMAT_NV12MT:
184 return "TBM_FORMAT_NV12MT";
192 _tbm_surface_mutex_init(void)
194 static bool tbm_surface_mutex_init = false;
196 if (tbm_surface_mutex_init)
199 if (pthread_mutex_init(&tbm_surface_lock, NULL)) {
200 TBM_LOG_E("fail: tbm_surface mutex init\n");
204 tbm_surface_mutex_init = true;
210 _tbm_surface_mutex_lock(void)
212 if (!_tbm_surface_mutex_init())
215 pthread_mutex_lock(&tbm_surface_lock);
219 _tbm_surface_mutex_unlock(void)
221 pthread_mutex_unlock(&tbm_surface_lock);
225 _init_surface_bufmgr(void)
227 g_surface_bufmgr = tbm_bufmgr_init(-1);
231 _deinit_surface_bufmgr(void)
233 if (!g_surface_bufmgr)
236 tbm_bufmgr_deinit(g_surface_bufmgr);
237 g_surface_bufmgr = NULL;
241 _tbm_surface_internal_query_plane_data(tbm_surface_h surface,
242 int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
244 TBM_RETURN_VAL_IF_FAIL(surface, 0);
245 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
247 struct _tbm_surface *surf = (struct _tbm_surface *)surface;
248 struct _tbm_bufmgr *mgr = surf->bufmgr;
251 TBM_RETURN_VAL_IF_FAIL(mgr != NULL, 0);
252 TBM_RETURN_VAL_IF_FAIL(surf->info.width > 0, 0);
253 TBM_RETURN_VAL_IF_FAIL(surf->info.height > 0, 0);
254 TBM_RETURN_VAL_IF_FAIL(surf->info.format > 0, 0);
256 if (!mgr->backend->surface_get_plane_data)
259 ret = mgr->backend->surface_get_plane_data(surf->info.width,
260 surf->info.height, surf->info.format, plane_idx, size, offset, pitch, bo_idx);
268 _tbm_surface_internal_destroy(tbm_surface_h surface)
271 tbm_bufmgr bufmgr = surface->bufmgr;
272 tbm_user_data *old_data = NULL, *tmp = NULL;
274 for (i = 0; i < surface->num_bos; i++) {
275 surface->bos[i]->surface = NULL;
277 tbm_bo_unref(surface->bos[i]);
278 surface->bos[i] = NULL;
281 /* destory the user_data_list */
282 if (!LIST_IS_EMPTY(&surface->user_data_list)) {
283 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &surface->user_data_list, item_link) {
284 DBG("free user_data\n");
285 user_data_delete(old_data);
289 LIST_DEL(&surface->item_link);
294 if (LIST_IS_EMPTY(&bufmgr->surf_list)) {
295 LIST_DELINIT(&bufmgr->surf_list);
296 _deinit_surface_bufmgr();
301 tbm_surface_internal_is_valid(tbm_surface_h surface)
303 tbm_surface_h old_data = NULL, tmp = NULL;
305 if (surface == NULL || g_surface_bufmgr == NULL)
308 if (!LIST_IS_EMPTY(&g_surface_bufmgr->surf_list)) {
309 LIST_FOR_EACH_ENTRY_SAFE(old_data, tmp, &g_surface_bufmgr->surf_list, item_link) {
310 if (old_data == surface)
318 tbm_surface_internal_query_supported_formats(uint32_t **formats,
321 struct _tbm_bufmgr *mgr;
324 _tbm_surface_mutex_lock();
326 if (!g_surface_bufmgr) {
327 _init_surface_bufmgr();
328 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
331 mgr = g_surface_bufmgr;
333 if (!mgr->backend->surface_supported_format) {
334 _tbm_surface_mutex_unlock();
338 ret = mgr->backend->surface_supported_format(formats, num);
340 _tbm_surface_mutex_unlock();
346 tbm_surface_internal_get_num_planes(tbm_format format)
352 case TBM_FORMAT_RGB332:
353 case TBM_FORMAT_BGR233:
354 case TBM_FORMAT_XRGB4444:
355 case TBM_FORMAT_XBGR4444:
356 case TBM_FORMAT_RGBX4444:
357 case TBM_FORMAT_BGRX4444:
358 case TBM_FORMAT_ARGB4444:
359 case TBM_FORMAT_ABGR4444:
360 case TBM_FORMAT_RGBA4444:
361 case TBM_FORMAT_BGRA4444:
362 case TBM_FORMAT_XRGB1555:
363 case TBM_FORMAT_XBGR1555:
364 case TBM_FORMAT_RGBX5551:
365 case TBM_FORMAT_BGRX5551:
366 case TBM_FORMAT_ARGB1555:
367 case TBM_FORMAT_ABGR1555:
368 case TBM_FORMAT_RGBA5551:
369 case TBM_FORMAT_BGRA5551:
370 case TBM_FORMAT_RGB565:
371 case TBM_FORMAT_BGR565:
372 case TBM_FORMAT_RGB888:
373 case TBM_FORMAT_BGR888:
374 case TBM_FORMAT_XRGB8888:
375 case TBM_FORMAT_XBGR8888:
376 case TBM_FORMAT_RGBX8888:
377 case TBM_FORMAT_BGRX8888:
378 case TBM_FORMAT_ARGB8888:
379 case TBM_FORMAT_ABGR8888:
380 case TBM_FORMAT_RGBA8888:
381 case TBM_FORMAT_BGRA8888:
382 case TBM_FORMAT_XRGB2101010:
383 case TBM_FORMAT_XBGR2101010:
384 case TBM_FORMAT_RGBX1010102:
385 case TBM_FORMAT_BGRX1010102:
386 case TBM_FORMAT_ARGB2101010:
387 case TBM_FORMAT_ABGR2101010:
388 case TBM_FORMAT_RGBA1010102:
389 case TBM_FORMAT_BGRA1010102:
390 case TBM_FORMAT_YUYV:
391 case TBM_FORMAT_YVYU:
392 case TBM_FORMAT_UYVY:
393 case TBM_FORMAT_VYUY:
394 case TBM_FORMAT_AYUV:
397 case TBM_FORMAT_NV12:
398 case TBM_FORMAT_NV12MT:
399 case TBM_FORMAT_NV21:
400 case TBM_FORMAT_NV16:
401 case TBM_FORMAT_NV61:
404 case TBM_FORMAT_YUV410:
405 case TBM_FORMAT_YVU410:
406 case TBM_FORMAT_YUV411:
407 case TBM_FORMAT_YVU411:
408 case TBM_FORMAT_YUV420:
409 case TBM_FORMAT_YVU420:
410 case TBM_FORMAT_YUV422:
411 case TBM_FORMAT_YVU422:
412 case TBM_FORMAT_YUV444:
413 case TBM_FORMAT_YVU444:
425 tbm_surface_internal_get_bpp(tbm_format format)
431 case TBM_FORMAT_RGB332:
432 case TBM_FORMAT_BGR233:
435 case TBM_FORMAT_XRGB4444:
436 case TBM_FORMAT_XBGR4444:
437 case TBM_FORMAT_RGBX4444:
438 case TBM_FORMAT_BGRX4444:
439 case TBM_FORMAT_ARGB4444:
440 case TBM_FORMAT_ABGR4444:
441 case TBM_FORMAT_RGBA4444:
442 case TBM_FORMAT_BGRA4444:
443 case TBM_FORMAT_XRGB1555:
444 case TBM_FORMAT_XBGR1555:
445 case TBM_FORMAT_RGBX5551:
446 case TBM_FORMAT_BGRX5551:
447 case TBM_FORMAT_ARGB1555:
448 case TBM_FORMAT_ABGR1555:
449 case TBM_FORMAT_RGBA5551:
450 case TBM_FORMAT_BGRA5551:
451 case TBM_FORMAT_RGB565:
452 case TBM_FORMAT_BGR565:
455 case TBM_FORMAT_RGB888:
456 case TBM_FORMAT_BGR888:
459 case TBM_FORMAT_XRGB8888:
460 case TBM_FORMAT_XBGR8888:
461 case TBM_FORMAT_RGBX8888:
462 case TBM_FORMAT_BGRX8888:
463 case TBM_FORMAT_ARGB8888:
464 case TBM_FORMAT_ABGR8888:
465 case TBM_FORMAT_RGBA8888:
466 case TBM_FORMAT_BGRA8888:
467 case TBM_FORMAT_XRGB2101010:
468 case TBM_FORMAT_XBGR2101010:
469 case TBM_FORMAT_RGBX1010102:
470 case TBM_FORMAT_BGRX1010102:
471 case TBM_FORMAT_ARGB2101010:
472 case TBM_FORMAT_ABGR2101010:
473 case TBM_FORMAT_RGBA1010102:
474 case TBM_FORMAT_BGRA1010102:
475 case TBM_FORMAT_YUYV:
476 case TBM_FORMAT_YVYU:
477 case TBM_FORMAT_UYVY:
478 case TBM_FORMAT_VYUY:
479 case TBM_FORMAT_AYUV:
482 case TBM_FORMAT_NV12:
483 case TBM_FORMAT_NV12MT:
484 case TBM_FORMAT_NV21:
487 case TBM_FORMAT_NV16:
488 case TBM_FORMAT_NV61:
491 case TBM_FORMAT_YUV410:
492 case TBM_FORMAT_YVU410:
495 case TBM_FORMAT_YUV411:
496 case TBM_FORMAT_YVU411:
497 case TBM_FORMAT_YUV420:
498 case TBM_FORMAT_YVU420:
501 case TBM_FORMAT_YUV422:
502 case TBM_FORMAT_YVU422:
505 case TBM_FORMAT_YUV444:
506 case TBM_FORMAT_YVU444:
517 tbm_surface_internal_create_with_flags(int width, int height,
518 int format, int flags)
520 TBM_RETURN_VAL_IF_FAIL(width > 0, NULL);
521 TBM_RETURN_VAL_IF_FAIL(height > 0, NULL);
523 struct _tbm_bufmgr *mgr;
524 struct _tbm_surface *surf = NULL;
528 uint32_t bo_size = 0;
532 _tbm_surface_mutex_lock();
534 if (!g_surface_bufmgr) {
535 _init_surface_bufmgr();
536 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
539 mgr = g_surface_bufmgr;
540 if (!TBM_BUFMGR_IS_VALID(mgr)) {
541 _tbm_surface_mutex_unlock();
544 surf = calloc(1, sizeof(struct _tbm_surface));
546 _tbm_surface_mutex_unlock();
551 surf->info.width = width;
552 surf->info.height = height;
553 surf->info.format = format;
554 surf->info.bpp = tbm_surface_internal_get_bpp(format);
555 surf->info.num_planes = tbm_surface_internal_get_num_planes(format);
558 /* get size, stride and offset bo_idx */
559 for (i = 0; i < surf->info.num_planes; i++) {
560 _tbm_surface_internal_query_plane_data(surf, i, &size, &offset, &stride,
562 surf->info.planes[i].size = size;
563 surf->info.planes[i].offset = offset;
564 surf->info.planes[i].stride = stride;
565 surf->planes_bo_idx[i] = bo_idx;
570 for (i = 0; i < surf->info.num_planes; i++) {
571 surf->info.size += surf->info.planes[i].size;
573 if (surf->num_bos < surf->planes_bo_idx[i] + 1)
574 surf->num_bos = surf->planes_bo_idx[i] + 1;
579 for (i = 0; i < surf->num_bos; i++) {
581 for (j = 0; j < surf->info.num_planes; j++) {
582 if (surf->planes_bo_idx[j] == i)
583 bo_size += surf->info.planes[j].size;
586 if (mgr->backend->surface_bo_alloc) {
587 /* LCOV_EXCL_START */
589 void *bo_priv = NULL;
591 bo = calloc(1, sizeof(struct _tbm_bo));
593 TBM_LOG_E("fail to alloc bo struct\n");
597 bo->bufmgr = surf->bufmgr;
599 pthread_mutex_lock(&surf->bufmgr->lock);
601 bo_priv = mgr->backend->surface_bo_alloc(bo, width, height, format, flags, i);
603 TBM_LOG_E("fail to alloc bo priv\n");
605 pthread_mutex_unlock(&surf->bufmgr->lock);
613 LIST_INITHEAD(&bo->user_data_list);
615 LIST_ADD(&bo->item_link, &surf->bufmgr->bo_list);
617 pthread_mutex_unlock(&surf->bufmgr->lock);
622 surf->bos[i] = tbm_bo_alloc(mgr, bo_size, flags);
626 TBM_LOG_E("fail to alloc bo idx:%d\n", i);
630 _tbm_bo_set_surface(surf->bos[i], surf);
634 LIST_INITHEAD(&surf->user_data_list);
636 LIST_ADD(&surf->item_link, &mgr->surf_list);
638 _tbm_surface_mutex_unlock();
643 for (j = 0; j < i; j++) {
645 tbm_bo_unref(surf->bos[j]);
651 if (LIST_IS_EMPTY(&mgr->surf_list)) {
652 LIST_DELINIT(&mgr->surf_list);
653 _deinit_surface_bufmgr();
656 _tbm_surface_mutex_unlock();
661 tbm_surface_internal_create_with_bos(tbm_surface_info_s *info,
662 tbm_bo *bos, int num)
664 TBM_RETURN_VAL_IF_FAIL(bos, NULL);
665 TBM_RETURN_VAL_IF_FAIL(info, NULL);
666 TBM_RETURN_VAL_IF_FAIL(num == 1 || info->num_planes == num, NULL);
668 struct _tbm_bufmgr *mgr;
669 struct _tbm_surface *surf = NULL;
672 _tbm_surface_mutex_lock();
674 if (!g_surface_bufmgr) {
675 _init_surface_bufmgr();
676 LIST_INITHEAD(&g_surface_bufmgr->surf_list);
679 mgr = g_surface_bufmgr;
680 if (!TBM_BUFMGR_IS_VALID(mgr)) {
681 _tbm_surface_mutex_unlock();
685 surf = calloc(1, sizeof(struct _tbm_surface));
687 _tbm_surface_mutex_unlock();
692 surf->info.width = info->width;
693 surf->info.height = info->height;
694 surf->info.format = info->format;
695 surf->info.bpp = info->bpp;
696 surf->info.num_planes = info->num_planes;
699 /* get size, stride and offset */
700 for (i = 0; i < info->num_planes; i++) {
701 surf->info.planes[i].offset = info->planes[i].offset;
702 surf->info.planes[i].stride = info->planes[i].stride;
704 if (info->planes[i].size > 0)
705 surf->info.planes[i].size = info->planes[i].size;
707 surf->info.planes[i].size += surf->info.planes[i].stride * info->height;
710 surf->planes_bo_idx[i] = 0;
712 surf->planes_bo_idx[i] = i;
715 if (info->size > 0) {
716 surf->info.size = info->size;
719 for (i = 0; i < info->num_planes; i++)
720 surf->info.size += surf->info.planes[i].size;
723 surf->flags = TBM_BO_DEFAULT;
725 /* create only one bo */
727 for (i = 0; i < num; i++) {
731 surf->bos[i] = tbm_bo_ref(bos[i]);
732 _tbm_bo_set_surface(bos[i], surf);
735 LIST_INITHEAD(&surf->user_data_list);
737 LIST_ADD(&surf->item_link, &mgr->surf_list);
739 _tbm_surface_mutex_unlock();
743 for (i = 0; i < num; i++) {
745 tbm_bo_unref(surf->bos[i]);
753 if (LIST_IS_EMPTY(&g_surface_bufmgr->surf_list)) {
754 LIST_DELINIT(&g_surface_bufmgr->surf_list);
755 _deinit_surface_bufmgr();
758 _tbm_surface_mutex_unlock();
764 tbm_surface_internal_destroy(tbm_surface_h surface)
766 if (!tbm_surface_internal_is_valid(surface))
769 _tbm_surface_mutex_lock();
773 if (surface->refcnt > 0) {
774 _tbm_surface_mutex_unlock();
778 if (surface->refcnt == 0)
779 _tbm_surface_internal_destroy(surface);
781 _tbm_surface_mutex_unlock();
785 tbm_surface_internal_ref(tbm_surface_h surface)
787 TBM_RETURN_IF_FAIL(tbm_surface_internal_is_valid(surface));
789 _tbm_surface_mutex_lock();
793 _tbm_surface_mutex_unlock();
797 tbm_surface_internal_unref(tbm_surface_h surface)
799 TBM_RETURN_IF_FAIL(tbm_surface_internal_is_valid(surface));
801 _tbm_surface_mutex_lock();
805 if (surface->refcnt > 0) {
806 _tbm_surface_mutex_unlock();
810 if (surface->refcnt == 0)
811 _tbm_surface_internal_destroy(surface);
813 _tbm_surface_mutex_unlock();
817 tbm_surface_internal_get_num_bos(tbm_surface_h surface)
819 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
821 struct _tbm_surface *surf;
824 _tbm_surface_mutex_lock();
826 surf = (struct _tbm_surface *)surface;
829 _tbm_surface_mutex_unlock();
835 tbm_surface_internal_get_bo(tbm_surface_h surface, int bo_idx)
837 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), NULL);
838 TBM_RETURN_VAL_IF_FAIL(bo_idx > -1, NULL);
840 struct _tbm_surface *surf;
843 _tbm_surface_mutex_lock();
845 surf = (struct _tbm_surface *)surface;
846 bo = surf->bos[bo_idx];
848 _tbm_surface_mutex_unlock();
854 tbm_surface_internal_get_size(tbm_surface_h surface)
856 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
858 struct _tbm_surface *surf;
861 _tbm_surface_mutex_lock();
863 surf = (struct _tbm_surface *)surface;
864 size = surf->info.size;
866 _tbm_surface_mutex_unlock();
872 tbm_surface_internal_get_plane_data(tbm_surface_h surface, int plane_idx,
873 uint32_t *size, uint32_t *offset, uint32_t *pitch)
875 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
876 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
878 struct _tbm_surface *surf;
880 _tbm_surface_mutex_lock();
882 surf = (struct _tbm_surface *)surface;
884 if (plane_idx >= surf->info.num_planes) {
885 _tbm_surface_mutex_unlock();
890 *size = surf->info.planes[plane_idx].size;
893 *offset = surf->info.planes[plane_idx].offset;
896 *pitch = surf->info.planes[plane_idx].stride;
898 _tbm_surface_mutex_unlock();
904 tbm_surface_internal_get_info(tbm_surface_h surface, int opt,
905 tbm_surface_info_s *info, int map)
907 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
909 struct _tbm_surface *surf;
910 tbm_bo_handle bo_handles[4];
913 _tbm_surface_mutex_lock();
915 memset(bo_handles, 0, sizeof(tbm_bo_handle) * 4);
917 surf = (struct _tbm_surface *)surface;
919 memset(info, 0x00, sizeof(tbm_surface_info_s));
920 info->width = surf->info.width;
921 info->height = surf->info.height;
922 info->format = surf->info.format;
923 info->bpp = surf->info.bpp;
924 info->size = surf->info.size;
925 info->num_planes = surf->info.num_planes;
928 for (i = 0; i < surf->num_bos; i++) {
929 bo_handles[i] = tbm_bo_map(surf->bos[i], TBM_DEVICE_CPU, opt);
930 if (bo_handles[i].ptr == NULL) {
931 for (j = 0; j < i; j++)
932 tbm_bo_unmap(surf->bos[j]);
934 _tbm_surface_mutex_unlock();
939 for (i = 0; i < surf->num_bos; i++)
940 bo_handles[i] = tbm_bo_get_handle(surf->bos[i], TBM_DEVICE_CPU);
943 for (i = 0; i < surf->info.num_planes; i++) {
944 info->planes[i].size = surf->info.planes[i].size;
945 info->planes[i].offset = surf->info.planes[i].offset;
946 info->planes[i].stride = surf->info.planes[i].stride;
948 if (bo_handles[surf->planes_bo_idx[i]].ptr)
949 info->planes[i].ptr = bo_handles[surf->planes_bo_idx[i]].ptr +
950 surf->info.planes[i].offset;
953 _tbm_surface_mutex_unlock();
959 tbm_surface_internal_unmap(tbm_surface_h surface)
961 TBM_RETURN_IF_FAIL(tbm_surface_internal_is_valid(surface));
963 struct _tbm_surface *surf;
966 _tbm_surface_mutex_lock();
968 surf = (struct _tbm_surface *)surface;
970 for (i = 0; i < surf->num_bos; i++)
971 tbm_bo_unmap(surf->bos[i]);
973 _tbm_surface_mutex_unlock();
977 tbm_surface_internal_get_width(tbm_surface_h surface)
979 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
981 struct _tbm_surface *surf;
984 _tbm_surface_mutex_lock();
986 surf = (struct _tbm_surface *)surface;
987 width = surf->info.width;
989 _tbm_surface_mutex_unlock();
995 tbm_surface_internal_get_height(tbm_surface_h surface)
997 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
999 struct _tbm_surface *surf;
1000 unsigned int height;
1002 _tbm_surface_mutex_lock();
1004 surf = (struct _tbm_surface *)surface;
1005 height = surf->info.height;
1007 _tbm_surface_mutex_unlock();
1014 tbm_surface_internal_get_format(tbm_surface_h surface)
1016 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1018 struct _tbm_surface *surf;
1021 _tbm_surface_mutex_lock();
1023 surf = (struct _tbm_surface *)surface;
1024 format = surf->info.format;
1026 _tbm_surface_mutex_unlock();
1032 tbm_surface_internal_get_plane_bo_idx(tbm_surface_h surface, int plane_idx)
1034 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1035 TBM_RETURN_VAL_IF_FAIL(plane_idx > -1, 0);
1036 struct _tbm_surface *surf;
1039 _tbm_surface_mutex_lock();
1041 surf = (struct _tbm_surface *)surface;
1042 bo_idx = surf->planes_bo_idx[plane_idx];
1044 _tbm_surface_mutex_unlock();
1050 tbm_surface_internal_add_user_data(tbm_surface_h surface, unsigned long key,
1051 tbm_data_free data_free_func)
1053 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1055 tbm_user_data *data;
1057 /* check if the data according to the key exist if so, return false. */
1058 data = user_data_lookup(&surface->user_data_list, key);
1060 TBM_LOG_W("waring user data already exist. key:%ld\n", key);
1064 data = user_data_create(key, data_free_func);
1068 LIST_ADD(&data->item_link, &surface->user_data_list);
1074 tbm_surface_internal_set_user_data(tbm_surface_h surface, unsigned long key,
1077 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1079 tbm_user_data *old_data;
1081 if (LIST_IS_EMPTY(&surface->user_data_list))
1084 old_data = user_data_lookup(&surface->user_data_list, key);
1088 if (old_data->data && old_data->free_func)
1089 old_data->free_func(old_data->data);
1091 old_data->data = data;
1097 tbm_surface_internal_get_user_data(tbm_surface_h surface, unsigned long key,
1100 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1102 tbm_user_data *old_data;
1104 if (!data || LIST_IS_EMPTY(&surface->user_data_list))
1107 old_data = user_data_lookup(&surface->user_data_list, key);
1113 *data = old_data->data;
1119 tbm_surface_internal_delete_user_data(tbm_surface_h surface,
1122 TBM_RETURN_VAL_IF_FAIL(tbm_surface_internal_is_valid(surface), 0);
1124 tbm_user_data *old_data = (void *)0;
1126 if (LIST_IS_EMPTY(&surface->user_data_list))
1129 old_data = user_data_lookup(&surface->user_data_list, key);
1133 user_data_delete(old_data);
1138 /* LCOV_EXCL_START */
1140 _tbm_surface_internal_get_debug_pid(tbm_surface_h surface)
1142 TBM_RETURN_VAL_IF_FAIL(surface, 0);
1144 return surface->debug_pid;
1148 tbm_surface_internal_set_debug_pid(tbm_surface_h surface, unsigned int pid)
1150 TBM_RETURN_IF_FAIL(tbm_surface_internal_is_valid(surface));
1152 surface->debug_pid = pid;
1155 typedef struct _tbm_surface_dump_info tbm_surface_dump_info;
1156 typedef struct _tbm_surface_dump_buf_info tbm_surface_dump_buf_info;
1158 struct _tbm_surface_dump_buf_info {
1168 tbm_surface_info_s info;
1170 struct list_head link;
1173 struct _tbm_surface_dump_info {
1174 char *path; // copy???
1177 struct list_head *link;
1178 struct list_head surface_list; /* link of surface */
1181 static tbm_surface_dump_info *g_dump_info = NULL;
1182 static const char *dump_postfix[2] = {"png", "yuv"};
1185 _tbm_surface_internal_dump_file_raw(const char *file, void *data1, int size1, void *data2,
1186 int size2, void *data3, int size3)
1188 unsigned int *blocks;
1189 FILE *fp = fopen(file, "w+");
1190 TBM_RETURN_IF_FAIL(fp != NULL);
1192 blocks = (unsigned int *)data1;
1193 fwrite(blocks, 1, size1, fp);
1196 blocks = (unsigned int *)data2;
1197 fwrite(blocks, 1, size2, fp);
1201 blocks = (unsigned int *)data3;
1202 fwrite(blocks, 1, size3, fp);
1209 _tbm_surface_internal_dump_file_png(const char *file, const void *data, int width,
1212 FILE *fp = fopen(file, "wb");
1213 TBM_RETURN_IF_FAIL(fp != NULL);
1216 png_structp pPngStruct =
1217 png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
1223 png_infop pPngInfo = png_create_info_struct(pPngStruct);
1225 png_destroy_write_struct(&pPngStruct, NULL);
1230 png_init_io(pPngStruct, fp);
1231 png_set_IHDR(pPngStruct,
1236 PNG_COLOR_TYPE_RGBA,
1238 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
1240 png_set_bgr(pPngStruct);
1241 png_write_info(pPngStruct, pPngInfo);
1243 const int pixel_size = 4; // RGBA
1244 png_bytep *row_pointers =
1245 png_malloc(pPngStruct, height * sizeof(png_byte *));
1247 unsigned int *blocks = (unsigned int *)data;
1251 for (; y < height; ++y) {
1253 png_malloc(pPngStruct, sizeof(png_byte) * width * pixel_size);
1254 row_pointers[y] = (png_bytep)row;
1255 for (x = 0; x < width; ++x) {
1256 unsigned int curBlock = blocks[y * width + x];
1257 row[x * pixel_size] = (curBlock & 0xFF);
1258 row[1 + x * pixel_size] = (curBlock >> 8) & 0xFF;
1259 row[2 + x * pixel_size] = (curBlock >> 16) & 0xFF;
1260 row[3 + x * pixel_size] = (curBlock >> 24) & 0xFF;
1264 png_write_image(pPngStruct, row_pointers);
1265 png_write_end(pPngStruct, pPngInfo);
1267 for (y = 0; y < height; y++)
1268 png_free(pPngStruct, row_pointers[y]);
1269 png_free(pPngStruct, row_pointers);
1271 png_destroy_write_struct(&pPngStruct, &pPngInfo);
1277 tbm_surface_internal_dump_start(char *path, int w, int h, int count)
1279 TBM_RETURN_IF_FAIL(path != NULL);
1280 TBM_RETURN_IF_FAIL(w > 0);
1281 TBM_RETURN_IF_FAIL(h > 0);
1282 TBM_RETURN_IF_FAIL(count > 0);
1284 tbm_surface_dump_buf_info *buf_info = NULL;
1285 tbm_surface_dump_buf_info *tmp;
1289 tbm_surface_h tbm_surface;
1290 tbm_surface_info_s info;
1291 tbm_surface_error_e err;
1295 TBM_LOG_W("waring already running the tbm_surface_internal_dump.\n");
1299 g_dump_info = calloc(1, sizeof(struct _tbm_surface_dump_info));
1300 TBM_RETURN_IF_FAIL(g_dump_info);
1302 LIST_INITHEAD(&g_dump_info->surface_list);
1303 g_dump_info->count = 0;
1304 g_dump_info->dump_max = count;
1306 /* get buffer size */
1307 tbm_surface = tbm_surface_create(w, h, TBM_FORMAT_ARGB8888);
1308 if (tbm_surface == NULL) {
1309 TBM_LOG_E("tbm_surface_create fail\n");
1314 err = tbm_surface_map(tbm_surface, TBM_SURF_OPTION_READ, &info);
1315 if (err != TBM_SURFACE_ERROR_NONE) {
1316 TBM_LOG_E("tbm_surface_map fail\n");
1317 tbm_surface_destroy(tbm_surface);
1322 buffer_size = info.planes[0].stride * h;
1323 tbm_surface_unmap(tbm_surface);
1324 tbm_surface_destroy(tbm_surface);
1326 /* create dump lists */
1327 for (i = 0; i < count; i++) {
1328 buf_info = calloc(1, sizeof(tbm_surface_dump_buf_info));
1329 TBM_GOTO_VAL_IF_FAIL(buf_info, fail);
1330 bo = tbm_bo_alloc(g_surface_bufmgr, buffer_size, TBM_BO_DEFAULT);
1336 buf_info->index = i;
1338 buf_info->size = buffer_size;
1340 LIST_ADDTAIL(&buf_info->link, &g_dump_info->surface_list);
1343 g_dump_info->path = path;
1344 g_dump_info->link = &g_dump_info->surface_list;
1346 TBM_LOG_I("Dump Start.. path:%s, count:%d\n", g_dump_info->path, count);
1350 /* free resources */
1351 if (!LIST_IS_EMPTY(&g_dump_info->surface_list)) {
1352 LIST_FOR_EACH_ENTRY_SAFE(buf_info, tmp, &g_dump_info->surface_list, link) {
1353 tbm_bo_unref(buf_info->bo);
1358 TBM_LOG_E("Dump Start fail.. path:%s\n", g_dump_info->path);
1367 tbm_surface_internal_dump_end(void)
1369 tbm_surface_dump_buf_info *buf_info = NULL, *tmp = NULL;
1370 tbm_bo_handle bo_handle;
1376 if (!LIST_IS_EMPTY(&g_dump_info->surface_list)) {
1377 LIST_FOR_EACH_ENTRY_SAFE(buf_info, tmp, &g_dump_info->surface_list, link) {
1380 if (buf_info->dirty) {
1384 bo_handle = tbm_bo_map(buf_info->bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
1385 if (bo_handle.ptr == NULL)
1388 snprintf(file, sizeof(file), "%s/%s", g_dump_info->path, buf_info->name);
1389 TBM_LOG_I("Dump File.. %s generated.\n", file);
1391 switch (buf_info->info.format) {
1392 case TBM_FORMAT_ARGB8888:
1393 case TBM_FORMAT_XRGB8888:
1394 _tbm_surface_internal_dump_file_png(file, bo_handle.ptr,
1395 buf_info->info.planes[0].stride >> 2, buf_info->info.height);
1397 case TBM_FORMAT_YVU420:
1398 case TBM_FORMAT_YUV420:
1399 ptr1 = bo_handle.ptr + buf_info->info.planes[0].stride * buf_info->info.height;
1400 ptr2 = ptr1 + buf_info->info.planes[1].stride * (buf_info->info.height >> 1);
1401 _tbm_surface_internal_dump_file_raw(file, bo_handle.ptr,
1402 buf_info->info.planes[0].stride * buf_info->info.height,
1404 buf_info->info.planes[1].stride * (buf_info->info.height >> 1),
1406 buf_info->info.planes[2].stride * (buf_info->info.height >> 1));
1408 case TBM_FORMAT_NV12:
1409 case TBM_FORMAT_NV21:
1410 ptr1 = bo_handle.ptr + buf_info->info.planes[0].stride * buf_info->info.height;
1411 _tbm_surface_internal_dump_file_raw(file, bo_handle.ptr,
1412 buf_info->info.planes[0].stride * buf_info->info.height,
1414 buf_info->info.planes[1].stride * (buf_info->info.height >> 1),
1417 case TBM_FORMAT_YUYV:
1418 case TBM_FORMAT_UYVY:
1419 _tbm_surface_internal_dump_file_raw(file, bo_handle.ptr,
1420 buf_info->info.planes[0].stride * buf_info->info.height,
1424 TBM_LOG_E("can't dump %c%c%c%c buffer", FOURCC_STR(buf_info->info.format));
1425 tbm_bo_unmap(buf_info->bo);
1429 tbm_bo_unmap(buf_info->bo);
1430 } else if (buf_info->dirty_shm) {
1431 bo_handle = tbm_bo_map(buf_info->bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
1432 if (bo_handle.ptr == NULL)
1435 snprintf(file, sizeof(file), "%s/%s", g_dump_info->path, buf_info->name);
1436 TBM_LOG_I("Dump File.. %s generated.\n", file);
1438 _tbm_surface_internal_dump_file_png(file, bo_handle.ptr,
1439 buf_info->shm_stride >> 2, buf_info->shm_h);
1441 tbm_bo_unmap(buf_info->bo);
1447 /* free resources */
1448 if (!LIST_IS_EMPTY(&g_dump_info->surface_list)) {
1449 LIST_FOR_EACH_ENTRY_SAFE(buf_info, tmp, &g_dump_info->surface_list, link) {
1450 tbm_bo_unref(buf_info->bo);
1458 TBM_LOG_I("Dump End..\n");
1462 tbm_surface_internal_dump_buffer(tbm_surface_h surface, const char *type)
1464 TBM_RETURN_IF_FAIL(surface != NULL);
1465 TBM_RETURN_IF_FAIL(type != NULL);
1467 tbm_surface_dump_buf_info *buf_info;
1468 tbm_surface_info_s info;
1469 struct list_head *next_link;
1470 tbm_bo_handle bo_handle;
1472 const char *postfix;
1477 next_link = g_dump_info->link->next;
1478 TBM_RETURN_IF_FAIL(next_link != NULL);
1480 if (next_link == &g_dump_info->surface_list) {
1481 next_link = next_link->next;
1482 TBM_RETURN_IF_FAIL(next_link != NULL);
1485 buf_info = LIST_ENTRY(tbm_surface_dump_buf_info, next_link, link);
1486 TBM_RETURN_IF_FAIL(buf_info != NULL);
1488 ret = tbm_surface_map(surface, TBM_SURF_OPTION_READ|TBM_SURF_OPTION_WRITE, &info);
1489 TBM_RETURN_IF_FAIL(ret == TBM_SURFACE_ERROR_NONE);
1491 if (info.size > buf_info->size) {
1492 TBM_LOG_W("Dump skip. surface over created buffer size(%d, %d)\n", info.size, buf_info->size);
1493 tbm_surface_unmap(surface);
1497 if (info.format == TBM_FORMAT_ARGB8888 || info.format == TBM_FORMAT_XRGB8888)
1498 postfix = dump_postfix[0];
1500 postfix = dump_postfix[1];
1502 /* make the file information */
1503 memcpy(&buf_info->info, &info, sizeof(tbm_surface_info_s));
1506 bo_handle = tbm_bo_map(buf_info->bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
1507 TBM_RETURN_IF_FAIL(bo_handle.ptr != NULL);
1508 memset(bo_handle.ptr, 0x00, buf_info->size);
1510 switch (info.format) {
1511 case TBM_FORMAT_ARGB8888:
1512 case TBM_FORMAT_XRGB8888:
1513 snprintf(buf_info->name, sizeof(buf_info->name), "[%.3f](%03d:%p)-%s.%s", _get_time_in_millis() / 1000.0, g_dump_info->count++, surface, type, postfix);
1514 memcpy(bo_handle.ptr, info.planes[0].ptr, info.size);
1516 case TBM_FORMAT_YVU420:
1517 case TBM_FORMAT_YUV420:
1518 snprintf(buf_info->name, sizeof(buf_info->name), "%03d-%s_%dx%d_%c%c%c%c.%s",
1519 g_dump_info->count++, type, info.planes[0].stride, info.height, FOURCC_STR(info.format), postfix);
1520 memcpy(bo_handle.ptr, info.planes[0].ptr, info.planes[0].stride * info.height);
1521 bo_handle.ptr += info.planes[0].stride * info.height;
1522 memcpy(bo_handle.ptr, info.planes[1].ptr, info.planes[1].stride * (info.height >> 1));
1523 bo_handle.ptr += info.planes[1].stride * (info.height >> 1);
1524 memcpy(bo_handle.ptr, info.planes[2].ptr, info.planes[2].stride * (info.height >> 1));
1526 case TBM_FORMAT_NV12:
1527 case TBM_FORMAT_NV21:
1528 snprintf(buf_info->name, sizeof(buf_info->name), "%03d-%s_%dx%d_%c%c%c%c.%s",
1529 g_dump_info->count++, type, info.planes[0].stride, info.height, FOURCC_STR(info.format), postfix);
1530 memcpy(bo_handle.ptr, info.planes[0].ptr, info.planes[0].stride * info.height);
1531 bo_handle.ptr += info.planes[0].stride * info.height;
1532 memcpy(bo_handle.ptr, info.planes[1].ptr, info.planes[1].stride * (info.height >> 1));
1534 case TBM_FORMAT_YUYV:
1535 case TBM_FORMAT_UYVY:
1536 snprintf(buf_info->name, sizeof(buf_info->name), "%03d-%s_%dx%d_%c%c%c%c.%s",
1537 g_dump_info->count++, type, info.planes[0].stride, info.height, FOURCC_STR(info.format), postfix);
1538 memcpy(bo_handle.ptr, info.planes[0].ptr, info.planes[0].stride * info.height);
1541 TBM_LOG_E("can't copy %c%c%c%c buffer", FOURCC_STR(info.format));
1542 tbm_bo_unmap(buf_info->bo);
1546 tbm_bo_unmap(buf_info->bo);
1548 tbm_surface_unmap(surface);
1550 buf_info->dirty = 1;
1551 buf_info->dirty_shm = 0;
1553 if (g_dump_info->count == 1000)
1554 g_dump_info->count = 0;
1556 g_dump_info->link = next_link;
1558 TBM_LOG_I("Dump %s \n", buf_info->name);
1561 void tbm_surface_internal_dump_shm_buffer(void *ptr, int w, int h, int stride, const char *type)
1563 TBM_RETURN_IF_FAIL(ptr != NULL);
1564 TBM_RETURN_IF_FAIL(w > 0);
1565 TBM_RETURN_IF_FAIL(h > 0);
1566 TBM_RETURN_IF_FAIL(stride > 0);
1567 TBM_RETURN_IF_FAIL(type != NULL);
1569 tbm_surface_dump_buf_info *buf_info;
1570 struct list_head *next_link;
1571 tbm_bo_handle bo_handle;
1576 next_link = g_dump_info->link->next;
1577 TBM_RETURN_IF_FAIL(next_link != NULL);
1579 if (next_link == &g_dump_info->surface_list) {
1580 next_link = next_link->next;
1581 TBM_RETURN_IF_FAIL(next_link != NULL);
1584 buf_info = LIST_ENTRY(tbm_surface_dump_buf_info, next_link, link);
1585 TBM_RETURN_IF_FAIL(buf_info != NULL);
1587 if (stride * h > buf_info->size) {
1588 TBM_LOG_W("Dump skip. shm buffer over created buffer size(%d, %d)\n", stride * h, buf_info->size);
1593 bo_handle = tbm_bo_map(buf_info->bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
1594 TBM_RETURN_IF_FAIL(bo_handle.ptr != NULL);
1595 memset(bo_handle.ptr, 0x00, buf_info->size);
1596 memset(&buf_info->info, 0x00, sizeof(tbm_surface_info_s));
1599 snprintf(buf_info->name, sizeof(buf_info->name), "%03d-%s.%s", g_dump_info->count++, type, dump_postfix[0]);
1600 memcpy(bo_handle.ptr, ptr, stride * h);
1602 tbm_bo_unmap(buf_info->bo);
1604 buf_info->dirty = 0;
1605 buf_info->dirty_shm = 1;
1606 buf_info->shm_stride = stride;
1607 buf_info->shm_h = h;
1609 if (g_dump_info->count == 1000)
1610 g_dump_info->count = 0;
1612 g_dump_info->link = next_link;
1614 TBM_LOG_I("Dump %s \n", buf_info->name);