2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <mm_util_imgp.h>
20 #include <mm_util_jpeg.h>
21 #include <mm_util_png.h>
22 #include <mm_util_gif.h>
23 #include <mm_util_bmp.h>
24 #include <image_util.h>
25 #include <image_util_private.h>
29 #define IMAGE_UTIL_STRING_VALID(str) \
30 ((str != NULL && strlen(str) > 0) ? true : false)
32 #define IMAGE_UTIL_SAFE_FREE(src) { if (src) {free(src); src = NULL; } }
34 static int _convert_colorspace_tbl[] = {
35 MM_UTIL_IMG_FMT_YUV420, /* IMAGE_UTIL_COLORSPACE_YUV420 */
36 MM_UTIL_IMG_FMT_YUV422, /* IMAGE_UTIL_COLORSPACE_YUV422 */
37 MM_UTIL_IMG_FMT_I420, /* IMAGE_UTIL_COLORSPACE_I420 */
38 MM_UTIL_IMG_FMT_NV12, /* IMAGE_UTIL_COLORSPACE_NV12 */
39 MM_UTIL_IMG_FMT_UYVY, /* IMAGE_UTIL_COLORSPACE_UYVY */
40 MM_UTIL_IMG_FMT_YUYV, /* IMAGE_UTIL_COLORSPACE_YUYV */
41 MM_UTIL_IMG_FMT_RGB565, /* IMAGE_UTIL_COLORSPACE_RGB565 */
42 MM_UTIL_IMG_FMT_RGB888, /* IMAGE_UTIL_COLORSPACE_RGB888 */
43 MM_UTIL_IMG_FMT_ARGB8888, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
44 MM_UTIL_IMG_FMT_BGRA8888, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
45 MM_UTIL_IMG_FMT_RGBA8888, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
46 MM_UTIL_IMG_FMT_BGRX8888, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
47 MM_UTIL_JPEG_FMT_NV21, /* IMAGE_UTIL_COLORSPACE_NV12 */
48 MM_UTIL_JPEG_FMT_NV16, /* IMAGE_UTIL_COLORSPACE_NV16 */
49 MM_UTIL_JPEG_FMT_NV61, /* IMAGE_UTIL_COLORSPACE_NV61 */
52 static int _convert_encode_colorspace_tbl[] = {
53 MM_UTIL_JPEG_FMT_YUV420, /* IMAGE_UTIL_COLORSPACE_YUV420 */
54 -1, /* IMAGE_UTIL_COLORSPACE_YUV422 */
55 MM_UTIL_JPEG_FMT_YUV420, /* IMAGE_UTIL_COLORSPACE_I420 */
56 MM_UTIL_JPEG_FMT_NV12, /* IMAGE_UTIL_COLORSPACE_NV12 */
57 -1, /* IMAGE_UTIL_COLORSPACE_UYVY */
58 -1, /* IMAGE_UTIL_COLORSPACE_YUYV */
59 -1, /* IMAGE_UTIL_COLORSPACE_RGB565 */
60 MM_UTIL_JPEG_FMT_RGB888, /* IMAGE_UTIL_COLORSPACE_RGB888 */
61 MM_UTIL_JPEG_FMT_ARGB8888, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
62 MM_UTIL_JPEG_FMT_BGRA8888, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
63 MM_UTIL_JPEG_FMT_RGBA8888, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
64 -1, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
65 -1, /* IMAGE_UTIL_COLORSPACE_NV21 */
66 -1, /* IMAGE_UTIL_COLORSPACE_NV16 */
67 -1, /* IMAGE_UTIL_COLORSPACE_NV61 */
70 static int _convert_jpeg_colorspace_tbl[] = {
71 MM_UTIL_JPEG_FMT_YUV420, /* IMAGE_UTIL_COLORSPACE_YUV420 */
72 -1, /* IMAGE_UTIL_COLORSPACE_YUV422 */
73 MM_UTIL_JPEG_FMT_YUV420, /* IMAGE_UTIL_COLORSPACE_I420 */
74 MM_UTIL_JPEG_FMT_NV12, /* IMAGE_UTIL_COLORSPACE_NV12 */
75 -1, /* IMAGE_UTIL_COLORSPACE_UYVY */
76 -1, /* IMAGE_UTIL_COLORSPACE_YUYV */
77 -1, /* IMAGE_UTIL_COLORSPACE_RGB565 */
78 MM_UTIL_JPEG_FMT_RGB888, /* IMAGE_UTIL_COLORSPACE_RGB888 */
79 MM_UTIL_JPEG_FMT_ARGB8888, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
80 MM_UTIL_JPEG_FMT_BGRA8888, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
81 MM_UTIL_JPEG_FMT_RGBA8888, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
82 -1, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
83 -1, /* IMAGE_UTIL_COLORSPACE_NV21 */
84 -1, /* IMAGE_UTIL_COLORSPACE_NV16 */
85 -1, /* IMAGE_UTIL_COLORSPACE_NV61 */
88 static int _convert_png_colorspace_tbl[] = {
89 -1, /* IMAGE_UTIL_COLORSPACE_YUV420 */
90 -1, /* IMAGE_UTIL_COLORSPACE_YUV422 */
91 -1, /* IMAGE_UTIL_COLORSPACE_I420 */
92 -1, /* IMAGE_UTIL_COLORSPACE_NV12 */
93 -1, /* IMAGE_UTIL_COLORSPACE_UYVY */
94 -1, /* IMAGE_UTIL_COLORSPACE_YUYV */
95 -1, /* IMAGE_UTIL_COLORSPACE_RGB565 */
96 -1, /* IMAGE_UTIL_COLORSPACE_RGB888 */
97 -1, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
98 -1, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
99 MM_UTIL_PNG_COLOR_TYPE_RGB_ALPHA, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
100 -1, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
101 -1, /* IMAGE_UTIL_COLORSPACE_NV21 */
102 -1, /* IMAGE_UTIL_COLORSPACE_NV16 */
103 -1, /* IMAGE_UTIL_COLORSPACE_NV61 */
106 static int _convert_gif_colorspace_tbl[] = {
107 -1, /* IMAGE_UTIL_COLORSPACE_YUV420 */
108 -1, /* IMAGE_UTIL_COLORSPACE_YUV422 */
109 -1, /* IMAGE_UTIL_COLORSPACE_I420 */
110 -1, /* IMAGE_UTIL_COLORSPACE_NV12 */
111 -1, /* IMAGE_UTIL_COLORSPACE_UYVY */
112 -1, /* IMAGE_UTIL_COLORSPACE_YUYV */
113 -1, /* IMAGE_UTIL_COLORSPACE_RGB565 */
114 -1, /* IMAGE_UTIL_COLORSPACE_RGB888 */
115 -1, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
116 -1, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
117 MM_UTIL_GIF_FMT_RGBA8888, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
118 -1, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
119 -1, /* IMAGE_UTIL_COLORSPACE_NV21 */
120 -1, /* IMAGE_UTIL_COLORSPACE_NV16 */
121 -1, /* IMAGE_UTIL_COLORSPACE_NV61 */
124 static int _convert_bmp_colorspace_tbl[] = {
125 -1, /* IMAGE_UTIL_COLORSPACE_YUV420 */
126 -1, /* IMAGE_UTIL_COLORSPACE_YUV422 */
127 -1, /* IMAGE_UTIL_COLORSPACE_I420 */
128 -1, /* IMAGE_UTIL_COLORSPACE_NV12 */
129 -1, /* IMAGE_UTIL_COLORSPACE_UYVY */
130 -1, /* IMAGE_UTIL_COLORSPACE_YUYV */
131 -1, /* IMAGE_UTIL_COLORSPACE_RGB565 */
132 -1, /* IMAGE_UTIL_COLORSPACE_RGB888 */
133 -1, /* IMAGE_UTIL_COLORSPACE_ARGB8888 */
134 -1, /* IMAGE_UTIL_COLORSPACE_BGRA8888 */
135 MM_UTIL_BMP_FMT_RGBA8888, /* IMAGE_UTIL_COLORSPACE_RGBA8888 */
136 -1, /* IMAGE_UTIL_COLORSPACE_BGRX8888 */
137 -1, /* IMAGE_UTIL_COLORSPACE_NV21 */
138 -1, /* IMAGE_UTIL_COLORSPACE_NV16 */
139 -1, /* IMAGE_UTIL_COLORSPACE_NV61 */
142 static int _convert_decode_scale_tbl[] = {
143 MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1,
144 MM_UTIL_JPEG_DECODE_DOWNSCALE_1_2,
145 MM_UTIL_JPEG_DECODE_DOWNSCALE_1_4,
146 MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8,
149 static int _convert_image_util_error_code(const char *func, int code)
151 int ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
152 char *errorstr = NULL;
154 case MM_UTIL_ERROR_NONE:
155 ret = IMAGE_UTIL_ERROR_NONE;
156 errorstr = strdup("ERROR_NONE");
158 case MM_UTIL_ERROR_NO_SUCH_FILE:
159 ret = IMAGE_UTIL_ERROR_NO_SUCH_FILE;
160 errorstr = strdup("NO_SUCH_FILE");
162 case MM_UTIL_ERROR_INVALID_PARAMETER:
163 ret = IMAGE_UTIL_ERROR_INVALID_PARAMETER;
164 errorstr = strdup("INVALID_PARAMETER");
166 case MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT:
167 ret = IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
168 errorstr = strdup("NOT_SUPPORTED_FORMAT");
170 case MM_UTIL_ERROR_OUT_OF_MEMORY:
171 ret = IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
172 errorstr = strdup("OUT_OF_MEMORY");
174 case MM_UTIL_ERROR_INVALID_OPERATION:
176 ret = IMAGE_UTIL_ERROR_INVALID_OPERATION;
177 errorstr = strdup("INVALID_OPERATION");
181 image_util_debug("[%s] %s(0x%08x)", func, errorstr, ret);
182 IMAGE_UTIL_SAFE_FREE(errorstr);
186 static image_util_error_e _image_util_error_convert(int error)
189 case MM_UTIL_ERROR_NONE:
190 image_util_debug("Error None");
191 return IMAGE_UTIL_ERROR_NONE;
192 case MM_UTIL_ERROR_INVALID_PARAMETER:
193 image_util_error("INVALID_PARAMETER(0x%08x)", IMAGE_UTIL_ERROR_INVALID_PARAMETER);
194 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
195 case MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT:
196 image_util_error("NOT_SUPPORTED_FORMAT(0x%08x)", IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT);
197 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
198 case MM_UTIL_ERROR_OUT_OF_MEMORY:
199 image_util_error("OUT_OF_MEMORY(0x%08x)", IMAGE_UTIL_ERROR_OUT_OF_MEMORY);
200 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
202 case MM_UTIL_ERROR_INVALID_OPERATION:
204 image_util_error("INVALID_OPERATION(0x%08x)", error);
205 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
209 static void _image_util_transform_completed_cb(media_packet_h * dst, int error, void *user_data)
211 int error_value = IMAGE_UTIL_ERROR_NONE;
212 image_util_cb_s *_util_cb = (image_util_cb_s *) user_data;
214 if ((_util_cb != NULL) && (_util_cb->image_processing_completed_cb != NULL)) {
215 error_value = _image_util_error_convert(error);
216 _util_cb->image_processing_completed_cb(dst, error_value, _util_cb->user_data);
222 static int _image_util_create_transform_handle(transformation_s * handle)
224 int err = MM_UTIL_ERROR_NONE;
225 mm_util_imgp_h image_h;
227 err = mm_util_create(&image_h);
228 if (err != MM_UTIL_ERROR_NONE) {
229 image_util_error("Error - mm_util_create");
230 return _convert_image_util_error_code(__func__, err);
233 handle->image_h = image_h;
235 return _convert_image_util_error_code(__func__, err);
238 static bool _image_util_check_resolution(int width, int height)
241 image_util_error("invalid width [%d]", width);
246 image_util_error("invalid height [%d]", height);
253 int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_colorspace_cb callback, void *user_data)
257 image_util_retvm_if((callback == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "callback is null");
259 /* RGB has higher precedence than YUV */
260 for (i = sizeof(_convert_encode_colorspace_tbl) / sizeof(int) - 1; i >= 0; i--) {
261 if (_convert_encode_colorspace_tbl[i] != -1)
262 if (false == callback(i, user_data))
263 return IMAGE_UTIL_ERROR_NONE;
267 return IMAGE_UTIL_ERROR_NONE;
270 int image_util_transform_create(transformation_h * handle)
272 int err = MM_UTIL_ERROR_NONE;
274 image_util_debug("image_util_create");
276 image_util_retvm_if((handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
278 transformation_s *_handle = (transformation_s *) calloc(1, sizeof(transformation_s));
279 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", IMAGE_UTIL_ERROR_OUT_OF_MEMORY);
281 _handle->colorspace = -1;
282 _handle->_util_cb = NULL;
283 _handle->image_h = 0;
284 _handle->hardware_acceleration = false;
285 _handle->set_convert = false;
286 _handle->set_resize = false;
287 _handle->set_rotate = false;
288 _handle->set_crop = false;
290 err = _image_util_create_transform_handle(_handle);
291 if (err != MM_UTIL_ERROR_NONE) {
292 image_util_error("Error - create transform handle");
293 IMAGE_UTIL_SAFE_FREE(_handle);
294 return _convert_image_util_error_code(__func__, err);
297 *handle = (transformation_h) _handle;
299 return _convert_image_util_error_code(__func__, err);
302 int image_util_transform_set_hardware_acceleration(transformation_h handle, bool mode)
304 int err = MM_UTIL_ERROR_NONE;
305 transformation_s *_handle = (transformation_s *) handle;
307 image_util_debug("Set hardware_acceleration %d", mode);
309 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
310 #ifndef ENABLE_HW_ACCELERATION
311 image_util_retvm_if((mode == true), IMAGE_UTIL_ERROR_NOT_SUPPORTED, "hardware acceleration is not supported");
314 err = mm_util_set_hardware_acceleration(_handle->image_h, mode);
315 if (err != MM_UTIL_ERROR_NONE) {
316 image_util_error("Error - Set hardware_acceleration");
317 return _convert_image_util_error_code(__func__, err);
320 image_util_debug("Set hardware_acceleration %d", mode);
321 _handle->hardware_acceleration = mode;
323 return _convert_image_util_error_code(__func__, err);
326 int image_util_transform_set_colorspace(transformation_h handle, image_util_colorspace_e colorspace)
328 int err = MM_UTIL_ERROR_NONE;
329 transformation_s *_handle = (transformation_s *) handle;
331 image_util_debug("Set colorspace_convert_info [%d]", colorspace);
333 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
335 err = mm_util_set_colorspace_convert(_handle->image_h, colorspace);
336 if (err != MM_UTIL_ERROR_NONE) {
337 image_util_error("Error - Set colorspace convert");
338 return _convert_image_util_error_code(__func__, err);
341 _handle->colorspace = colorspace;
342 _handle->set_convert = true;
344 return _convert_image_util_error_code(__func__, err);
347 int image_util_transform_set_resolution(transformation_h handle, unsigned int width, unsigned int height)
349 int err = MM_UTIL_ERROR_NONE;
350 transformation_s *_handle = (transformation_s *) handle;
352 image_util_debug("Set resize_info w[%d] h[%d]", width, height);
354 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
355 image_util_retvm_if((_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
356 image_util_retvm_if((_image_util_check_resolution(width, height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
358 err = mm_util_set_resolution(_handle->image_h, width, height);
359 if (err != MM_UTIL_ERROR_NONE) {
360 image_util_error("Error - Set resolution");
361 return _convert_image_util_error_code(__func__, err);
363 _handle->width = width;
364 _handle->height = height;
365 _handle->set_resize = true;
367 return _convert_image_util_error_code(__func__, err);
370 int image_util_transform_set_rotation(transformation_h handle, image_util_rotation_e rotation)
372 int err = MM_UTIL_ERROR_NONE;
373 transformation_s *_handle = (transformation_s *) handle;
375 image_util_debug("Set rotate_info [%d]", rotation);
377 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
379 err = mm_util_set_rotation(_handle->image_h, rotation);
380 if (err != MM_UTIL_ERROR_NONE) {
381 image_util_error("Error - Set rotation");
382 return _convert_image_util_error_code(__func__, err);
384 _handle->rotation = rotation;
385 _handle->set_rotate = true;
387 return _convert_image_util_error_code(__func__, err);
390 int image_util_transform_set_crop_area(transformation_h handle, unsigned int start_x, unsigned int start_y, unsigned int end_x, unsigned int end_y)
392 int err = MM_UTIL_ERROR_NONE;
393 transformation_s *_handle = (transformation_s *) handle;
397 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
398 image_util_retvm_if((_handle->set_resize), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
400 dest_width = end_x - start_x;
401 dest_height = end_y - start_y;
403 image_util_debug("Set crop_info x[%d] y[%d] w[%d] h[%d]", start_x, start_y, dest_width, dest_height);
405 image_util_retvm_if((_image_util_check_resolution(dest_width, dest_height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dest resolution");
406 err = mm_util_set_crop_area(_handle->image_h, start_x, start_y, end_x, end_y);
407 if (err != MM_UTIL_ERROR_NONE) {
408 image_util_error("Error - Set crop area");
409 return _convert_image_util_error_code(__func__, err);
411 _handle->start_x = start_x;
412 _handle->start_y = start_y;
413 _handle->end_x = end_x;
414 _handle->end_y = end_y;
415 _handle->set_crop = true;
417 return _convert_image_util_error_code(__func__, err);
420 int image_util_transform_get_colorspace(transformation_h handle, image_util_colorspace_e * colorspace)
422 int ret = IMAGE_UTIL_ERROR_NONE;
423 transformation_s *_handle = (transformation_s *) handle;
425 image_util_debug("Get colorspace_convert_info [%d]", colorspace);
427 if (_handle == NULL) {
428 image_util_error("Invalid Handle");
429 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
433 image_util_error("colorspace area parameter error");
434 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
437 if (!_handle->set_convert) {
438 image_util_error("Did not set colorspace before");
439 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
442 *colorspace = _handle->colorspace;
446 int image_util_transform_get_resolution(transformation_h handle, unsigned int *width, unsigned int *height)
448 int ret = IMAGE_UTIL_ERROR_NONE;
449 transformation_s *_handle = (transformation_s *) handle;
451 image_util_debug("Set resize_info w[%d] h[%d]", width, height);
453 if (_handle == NULL) {
454 image_util_error("Invalid Handle");
455 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
458 if (!width || !height) {
459 image_util_error("resolution area parameter error");
460 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
463 if (!_handle->set_resize) {
464 image_util_error("Did not set resolution before");
465 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
468 *width = _handle->width;
469 *height = _handle->height;
474 int image_util_transform_get_rotation(transformation_h handle, image_util_rotation_e * rotation)
476 int ret = IMAGE_UTIL_ERROR_NONE;
477 transformation_s *_handle = (transformation_s *) handle;
479 image_util_debug("Set rotate_info [%d]", rotation);
481 if (_handle == NULL) {
482 image_util_error("Invalid Handle");
483 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
487 image_util_error("rotation area parameter error");
488 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
491 if (!_handle->set_rotate) {
492 image_util_error("Did not set rotation before");
493 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
496 *rotation = _handle->rotation;
501 int image_util_transform_get_crop_area(transformation_h handle, unsigned int *start_x, unsigned int *start_y, unsigned int *end_x, unsigned int *end_y)
503 int ret = IMAGE_UTIL_ERROR_NONE;
504 transformation_s *_handle = (transformation_s *) handle;
506 if (_handle == NULL) {
507 image_util_error("Invalid Handle");
508 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
511 if (!start_x || !start_y || !end_x || !end_y) {
512 image_util_error("crop area parameter error");
513 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
516 if (!_handle->set_crop) {
517 image_util_error("Did not set crop area before");
518 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
521 *start_x = _handle->start_x;
522 *start_y = _handle->start_y;
523 *end_x = _handle->end_x;
524 *end_y = _handle->end_y;
529 int image_util_transform_run(transformation_h handle, media_packet_h src, image_util_transform_completed_cb completed_cb, void *user_data)
531 int err = MM_UTIL_ERROR_NONE;
532 transformation_s *_handle = (transformation_s *) handle;
534 image_util_debug("image_util_transform");
536 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
537 image_util_retvm_if((completed_cb == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid callback");
538 image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid source");
539 image_util_retvm_if((!_handle->set_convert && !_handle->set_resize && !_handle->set_rotate && !_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid transform");
541 if (_handle->_util_cb != NULL) {
542 IMAGE_UTIL_SAFE_FREE(_handle->_util_cb);
543 _handle->_util_cb = NULL;
545 _handle->_util_cb = (image_util_cb_s *) calloc(1, sizeof(image_util_cb_s));
546 image_util_retvm_if((_handle->_util_cb == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Out of memory");
548 _handle->_util_cb->user_data = user_data;
549 _handle->_util_cb->image_processing_completed_cb = completed_cb;
551 if (_handle->_util_cb)
552 err = mm_util_transform(_handle->image_h, src, (mm_util_completed_callback) _image_util_transform_completed_cb, (void *)_handle->_util_cb);
554 return _convert_image_util_error_code(__func__, err);
557 int image_util_transform_destroy(transformation_h handle)
559 int err = MM_UTIL_ERROR_NONE;
560 transformation_s *_handle = (transformation_s *) handle;
562 image_util_debug("image_util_destroy");
564 if (_handle == NULL) {
565 image_util_error("Invalid Handle");
566 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
569 err = mm_util_destroy(_handle->image_h);
571 IMAGE_UTIL_SAFE_FREE(_handle->_util_cb);
572 IMAGE_UTIL_SAFE_FREE(_handle);
574 return _convert_image_util_error_code(__func__, err);
577 int image_util_convert_colorspace(unsigned char *dest, image_util_colorspace_e dest_colorspace, const unsigned char *src, int width, int height, image_util_colorspace_e src_colorspace)
579 int err = MM_UTIL_ERROR_NONE;
581 image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
582 image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
583 image_util_retvm_if((dest_colorspace < 0 || dest_colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dst_colorspace");
584 image_util_retvm_if((src_colorspace < 0 || src_colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid src_colorspace");
586 err = mm_util_convert_colorspace(src, width, height, _convert_colorspace_tbl[src_colorspace], dest, _convert_colorspace_tbl[dest_colorspace]);
588 return _convert_image_util_error_code(__func__, err);
591 int image_util_calculate_buffer_size(int width, int height, image_util_colorspace_e colorspace, unsigned int *size)
593 int err = MM_UTIL_ERROR_NONE;
595 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
596 image_util_retvm_if((width <= 0 || height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid width or Invalid height");
597 image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
599 err = mm_util_get_image_size(_convert_colorspace_tbl[colorspace], width, height, size);
600 return _convert_image_util_error_code(__func__, err);
603 int image_util_resize(unsigned char *dest, int *dest_width, int *dest_height, const unsigned char *src, int src_width, int src_height, image_util_colorspace_e colorspace)
605 int err = MM_UTIL_ERROR_NONE;
607 image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
608 image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
609 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
610 image_util_retvm_if((dest_width == NULL || dest_height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest_width or dest_height is null");
611 image_util_retvm_if((*dest_width <= 0 || *dest_height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dest_width or Invalid dest_height");
613 unsigned int dest_w, dest_h;
614 dest_w = *dest_width;
615 dest_h = *dest_height;
616 err = mm_util_resize_image(src, src_width, src_height, _convert_colorspace_tbl[colorspace], dest, &dest_w, &dest_h);
617 if (err == MM_UTIL_ERROR_NONE) {
618 *dest_width = (int)dest_w;
619 *dest_height = (int)dest_h;
622 return _convert_image_util_error_code(__func__, err);
625 int image_util_rotate(unsigned char *dest, int *dest_width, int *dest_height, image_util_rotation_e dest_rotation, const unsigned char *src, int src_width, int src_height, image_util_colorspace_e colorspace)
627 int err = MM_UTIL_ERROR_NONE;
629 image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
630 image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
631 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
632 image_util_retvm_if((dest_rotation < 0 || dest_rotation > IMAGE_UTIL_ROTATION_FLIP_VERT), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid rotation");
633 image_util_retvm_if((dest_width == NULL || dest_height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest_width or dest_height is null");
635 unsigned int dest_w, dest_h;
636 err = mm_util_rotate_image(src, src_width, src_height, _convert_colorspace_tbl[colorspace], dest, &dest_w, &dest_h, dest_rotation);
637 if (err == MM_UTIL_ERROR_NONE) {
638 *dest_width = (int)dest_w;
639 *dest_height = (int)dest_h;
641 return _convert_image_util_error_code(__func__, err);
644 int image_util_crop(unsigned char *dest, int x, int y, int *width, int *height, const unsigned char *src, int src_width, int src_height, image_util_colorspace_e colorspace)
646 int err = MM_UTIL_ERROR_NONE;
648 image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
649 image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
650 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
651 image_util_retvm_if((width == NULL || height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "width or height is null");
652 image_util_retvm_if((src_width <= x || src_height <= y || src_width < x + *width || src_height < y + *height), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid crop area");
654 unsigned int dest_w, dest_h;
657 err = mm_util_crop_image(src, src_width, src_height, _convert_colorspace_tbl[colorspace], x, y, &dest_w, &dest_h, dest);
658 if (err == MM_UTIL_ERROR_NONE) {
659 *width = (int)dest_w;
660 *height = (int)dest_h;
663 return _convert_image_util_error_code(__func__, err);
666 int image_util_decode_jpeg(const char *path, image_util_colorspace_e colorspace, unsigned char **image_buffer, int *width, int *height, unsigned int *size)
668 int err = MM_UTIL_ERROR_NONE;
670 image_util_retvm_if((path == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "path is null");
671 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
672 image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
673 image_util_retvm_if((strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
674 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
675 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
677 mm_util_jpeg_yuv_data decoded;
678 memset(&decoded, 0, sizeof(mm_util_jpeg_yuv_data));
680 err = mm_util_decode_from_jpeg_file(&decoded, path, _convert_encode_colorspace_tbl[colorspace]);
681 if (err == MM_UTIL_ERROR_NONE) {
682 *image_buffer = decoded.data;
684 *width = decoded.width;
686 *height = decoded.height;
688 *size = (unsigned int)decoded.size;
690 return _convert_image_util_error_code(__func__, err);
693 int image_util_decode_jpeg_from_memory(const unsigned char *jpeg_buffer, int jpeg_size, image_util_colorspace_e colorspace, unsigned char **image_buffer, int *width, int *height, unsigned int *size)
695 int err = MM_UTIL_ERROR_NONE;
697 image_util_retvm_if((jpeg_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "jpeg_buffer is null");
698 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
699 image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
700 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
701 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
703 mm_util_jpeg_yuv_data decoded;
704 memset(&decoded, 0, sizeof(mm_util_jpeg_yuv_data));
706 err = mm_util_decode_from_jpeg_memory(&decoded, (void *)jpeg_buffer, jpeg_size, _convert_encode_colorspace_tbl[colorspace]);
708 if (err == MM_UTIL_ERROR_NONE) {
709 *image_buffer = decoded.data;
711 *width = decoded.width;
713 *height = decoded.height;
715 *size = (unsigned int)decoded.size;
718 return _convert_image_util_error_code(__func__, err);
721 int image_util_decode_jpeg_with_downscale(const char *path, image_util_colorspace_e colorspace, image_util_scale_e downscale, unsigned char **image_buffer, int *width, int *height, unsigned int *size)
723 int err = MM_UTIL_ERROR_NONE;
725 image_util_retvm_if((path == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "path is null");
726 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
727 image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
728 image_util_retvm_if((strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
729 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
730 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
731 image_util_retvm_if((downscale < 0 || downscale >= sizeof(_convert_decode_scale_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "downsacle is invalid");
733 mm_util_jpeg_yuv_data decoded;
734 memset(&decoded, 0, sizeof(mm_util_jpeg_yuv_data));
736 err = mm_util_decode_from_jpeg_file_with_downscale(&decoded, path, _convert_encode_colorspace_tbl[colorspace], _convert_decode_scale_tbl[downscale]);
737 if (err == MM_UTIL_ERROR_NONE) {
738 *image_buffer = decoded.data;
740 *width = decoded.width;
742 *height = decoded.height;
744 *size = (unsigned int)decoded.size;
746 return _convert_image_util_error_code(__func__, err);
749 int image_util_decode_jpeg_from_memory_with_downscale(const unsigned char *jpeg_buffer, int jpeg_size, image_util_colorspace_e colorspace, image_util_scale_e downscale, unsigned char **image_buffer, int *width, int *height, unsigned int *size)
751 int err = MM_UTIL_ERROR_NONE;
753 image_util_retvm_if((jpeg_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "jpeg_buffer is null");
754 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
755 image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
756 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
757 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
758 image_util_retvm_if((downscale < 0 || downscale >= sizeof(_convert_decode_scale_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "downsacle is invalid");
760 mm_util_jpeg_yuv_data decoded;
761 memset(&decoded, 0, sizeof(mm_util_jpeg_yuv_data));
763 err = mm_util_decode_from_jpeg_memory_with_downscale(&decoded, (void *)jpeg_buffer, jpeg_size, _convert_encode_colorspace_tbl[colorspace], _convert_decode_scale_tbl[downscale]);
765 if (err == MM_UTIL_ERROR_NONE) {
766 *image_buffer = decoded.data;
768 *width = decoded.width;
770 *height = decoded.height;
772 *size = (unsigned int)decoded.size;
775 return _convert_image_util_error_code(__func__, err);
778 int image_util_encode_jpeg(const unsigned char *buffer, int width, int height, image_util_colorspace_e colorspace, int quality, const char *path)
780 int err = MM_UTIL_ERROR_NONE;
782 image_util_retvm_if((path == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "path is null");
783 image_util_retvm_if((buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "buffer is null");
784 image_util_retvm_if((strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
785 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
786 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
788 err = mm_util_jpeg_encode_to_file(path, (void *)buffer, width, height, _convert_encode_colorspace_tbl[colorspace], quality);
789 return _convert_image_util_error_code(__func__, err);
792 int image_util_encode_jpeg_to_memory(const unsigned char *image_buffer, int width, int height, image_util_colorspace_e colorspace, int quality, unsigned char **jpeg_buffer, unsigned int *jpeg_size)
794 int err = MM_UTIL_ERROR_NONE;
797 image_util_retvm_if((jpeg_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "jpeg_buffer is null");
798 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
799 image_util_retvm_if((jpeg_size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "jpeg_size is null");
800 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
801 image_util_retvm_if((_convert_encode_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
803 err = mm_util_jpeg_encode_to_memory((void **)jpeg_buffer, &isize, (void *)image_buffer, width, height, _convert_encode_colorspace_tbl[colorspace], quality);
804 if (err == MM_UTIL_ERROR_NONE)
805 *jpeg_size = (unsigned int)isize;
807 return _convert_image_util_error_code(__func__, err);
810 int image_util_extract_color_from_memory(const unsigned char *image_buffer, int width, int height, unsigned char *rgb_r, unsigned char *rgb_g, unsigned char *rgb_b)
812 int ret = MM_UTIL_ERROR_NONE;
814 image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
816 GModule *module = NULL;
817 ModuleFunc mmutil_imgcv_module_func = NULL;
818 module = g_module_open(PATH_MMUTIL_IMGCV_LIB, G_MODULE_BIND_LAZY);
819 image_util_retvm_if((module == NULL), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "fail to open module");
821 g_module_symbol(module, IMGCV_FUNC_NAME, (gpointer *)&mmutil_imgcv_module_func);
822 if (!mmutil_imgcv_module_func)
823 g_module_close(module);
825 image_util_retvm_if((mmutil_imgcv_module_func == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "fail to get symbol");
827 unsigned char r_color, g_color, b_color;
828 ret = mmutil_imgcv_module_func((void *)image_buffer, width, height, &r_color, &g_color, &b_color);
835 g_module_close(module);
839 return _convert_image_util_error_code(__func__, ret);
842 int image_util_foreach_supported_colorspace(image_util_type_e image_type, image_util_supported_colorspace_cb callback, void *user_data)
846 image_util_retvm_if((callback == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "callback is null");
848 switch (image_type) {
849 case IMAGE_UTIL_JPEG:
850 /* RGB has higher precedence than YUV */
851 for (i = sizeof(_convert_jpeg_colorspace_tbl) / sizeof(int) - 1; i >= 0; i--) {
852 if (_convert_jpeg_colorspace_tbl[i] != -1)
853 if (false == callback(i, user_data))
854 return IMAGE_UTIL_ERROR_NONE;
859 for (i = sizeof(_convert_png_colorspace_tbl) / sizeof(int) - 1; i >= 0; i--) {
860 if (_convert_png_colorspace_tbl[i] != -1)
861 if (false == callback(i, user_data))
862 return IMAGE_UTIL_ERROR_NONE;
867 for (i = sizeof(_convert_gif_colorspace_tbl) / sizeof(int) - 1; i >= 0; i--) {
868 if (_convert_gif_colorspace_tbl[i] != -1)
869 if (false == callback(i, user_data))
870 return IMAGE_UTIL_ERROR_NONE;
875 for (i = sizeof(_convert_bmp_colorspace_tbl) / sizeof(int) - 1; i >= 0; i--) {
876 if (_convert_bmp_colorspace_tbl[i] != -1)
877 if (false == callback(i, user_data))
878 return IMAGE_UTIL_ERROR_NONE;
883 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
886 return IMAGE_UTIL_ERROR_NONE;
889 static int _image_util_decode_create_jpeg_handle(decode_encode_s * handle)
891 int err = MM_UTIL_ERROR_NONE;
893 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
895 mm_util_jpeg_yuv_data *_handle = (mm_util_jpeg_yuv_data *) calloc(1, sizeof(mm_util_jpeg_yuv_data));
896 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
898 handle->image_h = (mm_util_imgp_h) _handle;
899 handle->colorspace = IMAGE_UTIL_COLORSPACE_RGBA8888;
900 handle->down_scale = sizeof(image_util_scale_e);
905 static int _image_util_decode_create_png_handle(decode_encode_s * handle)
907 int err = MM_UTIL_ERROR_NONE;
909 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
911 mm_util_png_data *_handle = (mm_util_png_data *) calloc(1, sizeof(mm_util_png_data));
912 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
914 mm_util_init_decode_png(_handle);
916 handle->image_h = (mm_util_imgp_h) _handle;
921 static int _image_util_decode_create_gif_handle(decode_encode_s * handle)
923 int err = MM_UTIL_ERROR_NONE;
925 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
927 mm_util_gif_data *_handle = (mm_util_gif_data *) calloc(1, sizeof(mm_util_gif_data));
928 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
930 handle->image_h = (mm_util_imgp_h) _handle;
935 static int _image_util_decode_create_bmp_handle(decode_encode_s * handle)
937 int err = MM_UTIL_ERROR_NONE;
939 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
941 mm_util_bmp_data *_handle = (mm_util_bmp_data *) calloc(1, sizeof(mm_util_bmp_data));
942 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
944 handle->image_h = (mm_util_imgp_h) _handle;
949 int image_util_decode_create(image_util_decode_h * handle)
951 int err = MM_UTIL_ERROR_NONE;
953 image_util_debug("image_util_decode_create");
955 image_util_retvm_if((handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
957 decode_encode_s *_handle = (decode_encode_s *) calloc(1, sizeof(decode_encode_s));
958 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", IMAGE_UTIL_ERROR_OUT_OF_MEMORY);
960 _handle->src_buffer = NULL;
961 _handle->dst_buffer = NULL;
962 _handle->path = NULL;
963 _handle->image_h = 0;
964 _handle->is_decode = TRUE;
965 _handle->image_type = -1;
966 _handle->image_count = 1;
968 *handle = (image_util_decode_h) _handle;
970 return _convert_image_util_error_code(__func__, err);
973 static char _JPEG_HEADER[] = { 0xFF, 0xD8 };
974 static char _PNG_HEADER[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
975 static char _GIF_HEADER[] = { 'G', 'I', 'F' };
976 static char _BMP_HEADER[] = { 'B', 'M' };
978 static int _image_util_decode_create_image_handle(image_util_decode_h handle, const unsigned char *src_buffer)
980 image_util_type_e image_type = -1;
984 image_util_type_e image_type;
987 _JPEG_HEADER, sizeof(_JPEG_HEADER), IMAGE_UTIL_JPEG}
989 _PNG_HEADER, sizeof(_PNG_HEADER), IMAGE_UTIL_PNG}
991 _GIF_HEADER, sizeof(_GIF_HEADER), IMAGE_UTIL_GIF}
993 _BMP_HEADER, sizeof(_BMP_HEADER), IMAGE_UTIL_BMP}
996 int err = MM_UTIL_ERROR_NONE;
997 decode_encode_s *_handle = (decode_encode_s *) handle;
999 if (_handle == NULL || _handle->is_decode == FALSE) {
1000 image_util_error("Invalid Handle");
1001 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1003 if (src_buffer == NULL) {
1004 image_util_error("Invalid input buffer");
1005 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1008 for (i = 0; i < sizeof(image_header) / sizeof(image_header[0]); i++) {
1009 if (strncmp((const char *)src_buffer, image_header[i].header, image_header[i].size) == 0) {
1010 image_type = image_header[i].image_type;
1015 _handle->image_type = image_type;
1017 switch (image_type) {
1018 case IMAGE_UTIL_JPEG:
1019 err = _image_util_decode_create_jpeg_handle(_handle);
1021 case IMAGE_UTIL_PNG:
1022 err = _image_util_decode_create_png_handle(_handle);
1024 case IMAGE_UTIL_GIF:
1025 err = _image_util_decode_create_gif_handle(_handle);
1027 case IMAGE_UTIL_BMP:
1028 err = _image_util_decode_create_bmp_handle(_handle);
1031 err = MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1035 if (err != MM_UTIL_ERROR_NONE) {
1036 image_util_error("Error - create image handle");
1037 IMAGE_UTIL_SAFE_FREE(_handle);
1038 return _convert_image_util_error_code(__func__, err);
1041 return _convert_image_util_error_code(__func__, err);
1044 int image_util_decode_set_input_path(image_util_decode_h handle, const char *path)
1046 int err = IMAGE_UTIL_ERROR_NONE;
1047 decode_encode_s *_handle = (decode_encode_s *) handle;
1049 unsigned char *src_buffer = NULL;
1051 if (_handle == NULL || _handle->is_decode == FALSE) {
1052 image_util_error("Invalid Handle");
1053 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1055 image_util_retvm_if((path == NULL || strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
1057 if (_handle->src_buffer)
1058 _handle->src_buffer = NULL;
1060 fp = fopen(path, "r");
1062 image_util_error("File open failed %s", path);
1063 return IMAGE_UTIL_ERROR_NO_SUCH_FILE;
1065 src_buffer = (void *)malloc(sizeof(_PNG_HEADER));
1066 if (!fread(src_buffer, 1, sizeof(_PNG_HEADER), fp)) {
1067 image_util_error("File read failed");
1071 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
1074 err = _image_util_decode_create_image_handle(_handle, src_buffer);
1080 _handle->path = path;
1085 int image_util_decode_set_input_buffer(image_util_decode_h handle, const unsigned char *src_buffer, unsigned long long src_size)
1087 int err = IMAGE_UTIL_ERROR_NONE;
1088 decode_encode_s *_handle = (decode_encode_s *) handle;
1090 if (_handle == NULL || _handle->is_decode == FALSE) {
1091 image_util_error("Invalid Handle");
1092 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1094 if (src_buffer == NULL || src_size == 0) {
1095 image_util_error("Invalid input buffer");
1096 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1100 _handle->path = NULL;
1102 err = _image_util_decode_create_image_handle(_handle, src_buffer);
1104 if (!_handle->src_buffer)
1105 _handle->src_buffer = (void *)calloc(1, sizeof(void *));
1106 _handle->src_buffer[0] = (void *)src_buffer;
1107 _handle->src_size = src_size;
1112 int image_util_decode_set_output_buffer(image_util_decode_h handle, unsigned char **dst_buffer)
1114 int err = IMAGE_UTIL_ERROR_NONE;
1115 decode_encode_s *_handle = (decode_encode_s *) handle;
1117 if (_handle == NULL || _handle->is_decode == FALSE) {
1118 image_util_error("Invalid Handle");
1119 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1121 if (dst_buffer == NULL) {
1122 image_util_error("Invalid output buffer");
1123 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1126 _handle->dst_buffer = (void **)dst_buffer;
1131 int image_util_decode_set_colorspace(image_util_encode_h handle, image_util_colorspace_e colorspace)
1133 int err = IMAGE_UTIL_ERROR_NONE;
1134 decode_encode_s *_handle = (decode_encode_s *) handle;
1136 if (_handle == NULL || _handle->is_decode == FALSE) {
1137 image_util_error("Invalid Handle");
1138 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1141 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_jpeg_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
1142 switch (_handle->image_type) {
1143 case IMAGE_UTIL_JPEG:
1144 image_util_retvm_if((_convert_jpeg_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1146 case IMAGE_UTIL_PNG:
1147 image_util_retvm_if((_convert_png_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1149 case IMAGE_UTIL_GIF:
1150 image_util_retvm_if((_convert_gif_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1152 case IMAGE_UTIL_BMP:
1153 image_util_retvm_if((_convert_bmp_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1156 image_util_error("Invalid image type");
1157 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1160 _handle->colorspace = colorspace;
1165 int image_util_decode_set_jpeg_downscale(image_util_encode_h handle, image_util_scale_e down_scale)
1167 int err = IMAGE_UTIL_ERROR_NONE;
1168 decode_encode_s *_handle = (decode_encode_s *) handle;
1170 if (_handle == NULL || _handle->is_decode == FALSE) {
1171 image_util_error("Invalid Handle");
1172 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1174 if (_handle->image_type != IMAGE_UTIL_JPEG) {
1175 image_util_error("Wrong image format");
1176 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1178 image_util_retvm_if((down_scale < 0 || down_scale >= sizeof(image_util_scale_e)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "downscale is invalid");
1180 _handle->down_scale = down_scale;
1185 static int _image_util_decode_internal(decode_encode_s * _handle)
1187 int err = MM_UTIL_ERROR_NONE;
1189 switch (_handle->image_type) {
1190 case IMAGE_UTIL_JPEG:
1192 mm_util_jpeg_yuv_data *jpeg_data;
1194 jpeg_data = (mm_util_jpeg_yuv_data *) _handle->image_h;
1195 if (jpeg_data == NULL) {
1196 image_util_error("Invalid jpeg data");
1197 return MM_UTIL_ERROR_INVALID_PARAMETER;
1200 if (_handle->path) {
1201 if (_handle->down_scale < sizeof(image_util_scale_e))
1202 err = mm_util_decode_from_jpeg_file_with_downscale(jpeg_data, _handle->path, _convert_jpeg_colorspace_tbl[_handle->colorspace], _convert_decode_scale_tbl[_handle->down_scale]);
1204 err = mm_util_decode_from_jpeg_file(jpeg_data, _handle->path, _convert_jpeg_colorspace_tbl[_handle->colorspace]);
1206 if (_handle->down_scale < sizeof(image_util_scale_e))
1207 err = mm_util_decode_from_jpeg_memory_with_downscale(jpeg_data, _handle->src_buffer[0], _handle->src_size, _convert_jpeg_colorspace_tbl[_handle->colorspace], _convert_decode_scale_tbl[_handle->down_scale]);
1209 err = mm_util_decode_from_jpeg_memory(jpeg_data, _handle->src_buffer[0], _handle->src_size, _convert_jpeg_colorspace_tbl[_handle->colorspace]);
1212 if (err == MM_UTIL_ERROR_NONE) {
1213 *(_handle->dst_buffer) = jpeg_data->data;
1214 _handle->dst_size = (unsigned long long)jpeg_data->size;
1215 _handle->width = jpeg_data->width;
1216 _handle->height = jpeg_data->height;
1220 case IMAGE_UTIL_PNG:
1222 mm_util_png_data *png_data;
1224 png_data = (mm_util_png_data *) _handle->image_h;
1225 if (png_data == NULL) {
1226 image_util_error("Invalid png data");
1227 return MM_UTIL_ERROR_INVALID_PARAMETER;
1231 err = mm_util_decode_from_png_file(png_data, _handle->path);
1233 err = mm_util_decode_from_png_memory(png_data, &_handle->src_buffer[0], _handle->src_size);
1235 if (err == MM_UTIL_ERROR_NONE) {
1236 *(_handle->dst_buffer) = png_data->data;
1237 _handle->dst_size = png_data->size;
1238 _handle->width = png_data->width;
1239 _handle->height = png_data->height;
1243 case IMAGE_UTIL_GIF:
1245 mm_util_gif_data *gif_data;
1247 gif_data = (mm_util_gif_data *) _handle->image_h;
1248 if (gif_data == NULL) {
1249 image_util_error("Invalid gif data");
1250 return MM_UTIL_ERROR_INVALID_PARAMETER;
1254 err = mm_util_decode_from_gif_file(gif_data, _handle->path);
1256 err = mm_util_decode_from_gif_memory(gif_data, &_handle->src_buffer[0]);
1258 if (err == MM_UTIL_ERROR_NONE) {
1259 *(_handle->dst_buffer) = gif_data->frames[0]->data;
1260 _handle->dst_size = gif_data->size;
1261 _handle->width = gif_data->width;
1262 _handle->height = gif_data->height;
1266 case IMAGE_UTIL_BMP:
1268 mm_util_bmp_data *bmp_data;
1270 bmp_data = (mm_util_bmp_data *) _handle->image_h;
1271 if (bmp_data == NULL) {
1272 image_util_error("Invalid bmp data");
1273 return MM_UTIL_ERROR_INVALID_PARAMETER;
1277 err = mm_util_decode_from_bmp_file(bmp_data, _handle->path);
1279 err = mm_util_decode_from_bmp_memory(bmp_data, &_handle->src_buffer[0], _handle->src_size);
1281 if (err == MM_UTIL_ERROR_NONE) {
1282 *(_handle->dst_buffer) = bmp_data->data;
1283 _handle->dst_size = bmp_data->size;
1284 _handle->width = bmp_data->width;
1285 _handle->height = bmp_data->height;
1290 err = MM_UTIL_ERROR_INVALID_PARAMETER;
1297 int image_util_decode_run(image_util_decode_h handle, unsigned long *width, unsigned long *height, unsigned long long *size)
1299 int err = MM_UTIL_ERROR_NONE;
1300 decode_encode_s *_handle = (decode_encode_s *) handle;
1302 if (_handle == NULL || _handle->is_decode == FALSE) {
1303 image_util_error("Invalid Handle");
1304 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1306 if ((_handle->path == NULL && _handle->src_buffer == NULL) || _handle->dst_buffer == NULL) {
1307 image_util_error("Invalid input/output");
1308 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1311 err = _image_util_decode_internal(_handle);
1313 if (err != MM_UTIL_ERROR_NONE) {
1314 image_util_error("Error - decode run");
1315 return _convert_image_util_error_code(__func__, err);
1319 *width = _handle->width;
1321 *height = _handle->height;
1323 *size = _handle->dst_size;
1325 return _convert_image_util_error_code(__func__, err);
1328 gpointer _image_util_decode_thread(gpointer data)
1330 decode_encode_s *_handle = (decode_encode_s *) data;
1331 int err = MM_UTIL_ERROR_NONE;
1332 gint64 end_time = 0;
1335 image_util_error("[ERROR] - handle");
1339 while (!_handle->is_finish) {
1340 end_time = g_get_monotonic_time() + 1 * G_TIME_SPAN_SECOND;
1341 image_util_debug("waiting...");
1342 g_mutex_lock(&(_handle->thread_mutex));
1343 g_cond_wait_until(&(_handle->thread_cond), &(_handle->thread_mutex), end_time);
1344 image_util_debug("<=== get run decode thread signal");
1345 g_mutex_unlock(&(_handle->thread_mutex));
1347 if (_handle->is_finish) {
1348 image_util_debug("exit loop");
1352 err = _image_util_decode_internal(_handle);
1353 if (err == MM_UTIL_ERROR_NONE)
1354 image_util_debug("Success - decode_internal");
1356 image_util_error("Error - decode_internal");
1358 if (_handle->_decode_cb) {
1359 image_util_debug("completed_cb");
1360 _handle->is_finish = TRUE;
1361 _handle->_decode_cb->image_decode_completed_cb(_convert_image_util_error_code(__func__, err), _handle->_decode_cb->user_data, _handle->width, _handle->height, _handle->dst_size);
1365 image_util_debug("exit thread");
1370 static int _image_util_decode_create_thread(decode_encode_s * handle)
1372 int err = MM_UTIL_ERROR_NONE;
1374 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1376 g_mutex_init(&(handle->thread_mutex));
1378 g_cond_init(&(handle->thread_cond));
1381 handle->thread = g_thread_new("decode_thread", (GThreadFunc) _image_util_decode_thread, (gpointer) handle);
1382 if (!handle->thread) {
1383 image_util_error("ERROR - create thread");
1384 g_mutex_clear(&(handle->thread_mutex));
1386 g_cond_clear(&(handle->thread_cond));
1387 return MM_UTIL_ERROR_INVALID_OPERATION;
1393 int image_util_decode_run_async(image_util_decode_h handle, image_util_decode_completed_cb completed_cb, void *user_data)
1395 int err = MM_UTIL_ERROR_NONE;
1396 decode_encode_s *_handle = (decode_encode_s *) handle;
1398 if (_handle == NULL || _handle->is_decode == FALSE) {
1399 image_util_error("Invalid Handle");
1400 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1402 if ((_handle->path == NULL && _handle->src_buffer == NULL) || _handle->dst_buffer == NULL) {
1403 image_util_error("Invalid input/output");
1404 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1406 image_util_retvm_if((completed_cb == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid callback");
1408 if (_handle->_decode_cb != NULL) {
1409 IMAGE_UTIL_SAFE_FREE(_handle->_decode_cb);
1410 _handle->_decode_cb = NULL;
1412 _handle->_decode_cb = (decode_cb_s *) calloc(1, sizeof(decode_cb_s));
1413 image_util_retvm_if((_handle->_decode_cb == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Out of memory");
1415 _handle->_decode_cb->user_data = user_data;
1416 _handle->_decode_cb->image_decode_completed_cb = completed_cb;
1418 err = _image_util_decode_create_thread(_handle);
1420 return _convert_image_util_error_code(__func__, err);
1423 int image_util_decode_destroy(image_util_decode_h handle)
1425 int err = IMAGE_UTIL_ERROR_NONE;
1426 decode_encode_s *_handle = (decode_encode_s *) handle;
1428 image_util_debug("image_util_decode_destroy");
1430 if (_handle == NULL || _handle->is_decode == FALSE) {
1431 image_util_error("Invalid Handle");
1432 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1435 switch (_handle->image_type) {
1436 case IMAGE_UTIL_JPEG:
1438 mm_util_jpeg_yuv_data *jpeg_data;
1440 jpeg_data = (mm_util_jpeg_yuv_data *) _handle->image_h;
1441 if (jpeg_data == NULL) {
1442 image_util_error("Invalid jpeg data");
1443 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1445 IMAGE_UTIL_SAFE_FREE(jpeg_data);
1448 case IMAGE_UTIL_PNG:
1450 mm_util_png_data *png_data;
1452 png_data = (mm_util_png_data *) _handle->image_h;
1453 if (png_data == NULL) {
1454 image_util_error("Invalid png data");
1455 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1457 IMAGE_UTIL_SAFE_FREE(png_data);
1460 case IMAGE_UTIL_GIF:
1462 mm_util_gif_data *gif_data;
1464 gif_data = (mm_util_gif_data *) _handle->image_h;
1465 if (gif_data == NULL) {
1466 image_util_error("Invalid gif data");
1467 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1469 IMAGE_UTIL_SAFE_FREE(gif_data);
1472 case IMAGE_UTIL_BMP:
1474 mm_util_bmp_data *bmp_data;
1476 bmp_data = (mm_util_bmp_data *) _handle->image_h;
1477 if (bmp_data == NULL) {
1478 image_util_error("Invalid bmp data");
1479 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1481 IMAGE_UTIL_SAFE_FREE(bmp_data);
1488 /* g_thread_exit(handle->thread); */
1489 if (_handle->thread) {
1490 _handle->is_finish = TRUE;
1491 g_mutex_lock(&(_handle->thread_mutex));
1492 g_cond_signal(&(_handle->thread_cond));
1493 image_util_debug("===> send signal(finish) to decode_thread");
1494 g_mutex_unlock(&(_handle->thread_mutex));
1496 g_thread_join(_handle->thread);
1498 g_mutex_clear(&(_handle->thread_mutex));
1500 g_cond_clear(&(_handle->thread_cond));
1502 IMAGE_UTIL_SAFE_FREE(_handle->src_buffer);
1503 IMAGE_UTIL_SAFE_FREE(_handle);
1508 static int _image_util_encode_create_jpeg_handle(decode_encode_s * handle)
1510 int err = MM_UTIL_ERROR_NONE;
1512 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1514 mm_util_jpeg_yuv_data *_handle = (mm_util_jpeg_yuv_data *) calloc(1, sizeof(mm_util_jpeg_yuv_data));
1515 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
1517 handle->image_h = (mm_util_imgp_h) _handle;
1518 handle->colorspace = IMAGE_UTIL_COLORSPACE_RGBA8888;
1519 handle->quality = 75;
1524 static int _image_util_encode_create_png_handle(decode_encode_s * handle)
1526 int err = MM_UTIL_ERROR_NONE;
1528 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1530 mm_util_png_data *_handle = (mm_util_png_data *) calloc(1, sizeof(mm_util_png_data));
1531 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
1533 mm_util_init_encode_png(_handle);
1535 handle->image_h = (mm_util_imgp_h) _handle;
1540 static int _image_util_encode_create_gif_handle(decode_encode_s * handle)
1542 int err = MM_UTIL_ERROR_NONE;
1544 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1546 mm_util_gif_data *_handle = (mm_util_gif_data *) calloc(1, sizeof(mm_util_gif_data));
1547 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
1549 _handle->frames = (mm_util_gif_frame_data **) calloc(1, sizeof(mm_util_gif_frame_data *));
1550 if (_handle->frames == NULL) {
1551 image_util_error("Error - OUT_OF_MEMORY");
1552 IMAGE_UTIL_SAFE_FREE(_handle);
1553 return MM_UTIL_ERROR_OUT_OF_MEMORY;
1555 _handle->frames[0] = (mm_util_gif_frame_data *) calloc(1, sizeof(mm_util_gif_frame_data));
1556 if (_handle->frames[0] == NULL) {
1557 image_util_error("Error - OUT_OF_MEMORY");
1558 IMAGE_UTIL_SAFE_FREE(_handle);
1559 return MM_UTIL_ERROR_OUT_OF_MEMORY;
1562 handle->image_h = (mm_util_imgp_h) _handle;
1567 static int _image_util_encode_create_bmp_handle(decode_encode_s * handle)
1569 int err = MM_UTIL_ERROR_NONE;
1571 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1573 mm_util_bmp_data *_handle = (mm_util_bmp_data *) calloc(1, sizeof(mm_util_bmp_data));
1574 image_util_retvm_if((_handle == NULL), MM_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", MM_UTIL_ERROR_OUT_OF_MEMORY);
1576 handle->image_h = (mm_util_imgp_h) _handle;
1581 int image_util_encode_create(image_util_type_e image_type, image_util_encode_h * handle)
1583 int err = MM_UTIL_ERROR_NONE;
1585 image_util_debug("image_util_encode_create");
1587 image_util_retvm_if((handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
1589 decode_encode_s *_handle = (decode_encode_s *) calloc(1, sizeof(decode_encode_s));
1590 image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY(0x%08x)", IMAGE_UTIL_ERROR_OUT_OF_MEMORY);
1592 _handle->image_type = image_type;
1593 _handle->src_buffer = NULL;
1594 _handle->dst_buffer = NULL;
1595 _handle->path = NULL;
1596 _handle->image_h = 0;
1597 _handle->is_decode = FALSE;
1598 _handle->image_count = 1;
1599 _handle->current_buffer_count = 0;
1600 _handle->current_resolution_count = 0;
1601 _handle->current_delay_count = 0;
1603 switch (image_type) {
1604 case IMAGE_UTIL_JPEG:
1605 err = _image_util_encode_create_jpeg_handle(_handle);
1607 case IMAGE_UTIL_PNG:
1608 err = _image_util_encode_create_png_handle(_handle);
1610 case IMAGE_UTIL_GIF:
1611 err = _image_util_encode_create_gif_handle(_handle);
1613 case IMAGE_UTIL_BMP:
1614 err = _image_util_encode_create_bmp_handle(_handle);
1617 err = MM_UTIL_ERROR_INVALID_PARAMETER;
1621 if (err != MM_UTIL_ERROR_NONE) {
1622 image_util_error("Error - create image handle");
1623 IMAGE_UTIL_SAFE_FREE(_handle);
1624 return _convert_image_util_error_code(__func__, err);
1627 *handle = (image_util_encode_h) _handle;
1629 return _convert_image_util_error_code(__func__, err);
1632 int image_util_encode_set_resolution(image_util_encode_h handle, unsigned long width, unsigned long height)
1634 int err = IMAGE_UTIL_ERROR_NONE;
1635 decode_encode_s *_handle = (decode_encode_s *) handle;
1637 if (_handle == NULL || _handle->is_decode == TRUE) {
1638 image_util_error("Invalid Handle");
1639 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1641 image_util_retvm_if((_image_util_check_resolution(width, height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
1643 switch (_handle->image_type) {
1644 case IMAGE_UTIL_JPEG:
1646 mm_util_jpeg_yuv_data *jpeg_data;
1648 jpeg_data = (mm_util_jpeg_yuv_data *) _handle->image_h;
1649 if (jpeg_data == NULL) {
1650 image_util_error("Invalid jpeg data");
1651 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1653 jpeg_data->width = width;
1654 jpeg_data->height = height;
1657 case IMAGE_UTIL_PNG:
1659 mm_util_png_data *png_data;
1661 png_data = (mm_util_png_data *) _handle->image_h;
1662 if (png_data == NULL) {
1663 image_util_error("Invalid png data");
1664 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1666 mm_util_png_encode_set_width(png_data, width);
1667 mm_util_png_encode_set_height(png_data, height);
1670 case IMAGE_UTIL_GIF:
1672 mm_util_gif_data *gif_data;
1674 gif_data = (mm_util_gif_data *) _handle->image_h;
1675 if (gif_data == NULL) {
1676 image_util_error("Invalid gif data");
1677 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1680 if (!_handle->current_resolution_count) {
1681 mm_util_gif_encode_set_width(gif_data, width);
1682 mm_util_gif_encode_set_height(gif_data, height);
1683 _handle->width = width;
1684 _handle->height = height;
1685 } else if ((width > gif_data->frames[0]->width) || (height > gif_data->frames[0]->height)) {
1686 image_util_error("Image resolution cannot be more than the resolution of the first image");
1687 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1690 if (_handle->image_count <= _handle->current_resolution_count) {
1691 gif_data->frames = (mm_util_gif_frame_data **) realloc(gif_data->frames, (_handle->image_count + 1) * sizeof(mm_util_gif_frame_data *));
1692 if (gif_data->frames == NULL) {
1693 image_util_error("Error - OUT_OF_MEMORY");
1694 IMAGE_UTIL_SAFE_FREE(_handle);
1695 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1697 gif_data->frames[_handle->image_count] = (mm_util_gif_frame_data *) calloc(1, sizeof(mm_util_gif_frame_data));
1698 if (gif_data->frames[_handle->image_count] == NULL) {
1699 image_util_error("Error - OUT_OF_MEMORY");
1700 IMAGE_UTIL_SAFE_FREE(_handle);
1701 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1703 _handle->image_count++;
1706 gif_data->frames[_handle->current_resolution_count]->width = width;
1707 gif_data->frames[_handle->current_resolution_count]->height = height;
1708 _handle->current_resolution_count++;
1713 case IMAGE_UTIL_BMP:
1715 mm_util_bmp_data *bmp_data;
1717 bmp_data = (mm_util_bmp_data *) _handle->image_h;
1718 if (bmp_data == NULL) {
1719 image_util_error("Invalid bmp data");
1720 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1722 mm_util_bmp_encode_set_width(bmp_data, width);
1723 mm_util_bmp_encode_set_height(bmp_data, height);
1727 err = IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1731 _handle->width = width;
1732 _handle->height = height;
1737 int image_util_encode_set_colorspace(image_util_encode_h handle, image_util_colorspace_e colorspace)
1739 int err = IMAGE_UTIL_ERROR_NONE;
1740 decode_encode_s *_handle = (decode_encode_s *) handle;
1742 if (_handle == NULL || _handle->is_decode == TRUE) {
1743 image_util_error("Invalid Handle");
1744 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1747 image_util_retvm_if((colorspace < 0 || colorspace >= sizeof(_convert_jpeg_colorspace_tbl) / sizeof(int)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
1748 switch (_handle->image_type) {
1749 case IMAGE_UTIL_JPEG:
1750 image_util_retvm_if((_convert_jpeg_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1752 case IMAGE_UTIL_PNG:
1753 image_util_retvm_if((_convert_png_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1755 case IMAGE_UTIL_GIF:
1756 image_util_retvm_if((_convert_gif_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1758 case IMAGE_UTIL_BMP:
1759 image_util_retvm_if((_convert_bmp_colorspace_tbl[colorspace] == -1), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported format");
1762 image_util_error("Invalid image type");
1763 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1766 _handle->colorspace = colorspace;
1771 int image_util_encode_set_quality(image_util_encode_h handle, int quality)
1773 int err = IMAGE_UTIL_ERROR_NONE;
1774 decode_encode_s *_handle = (decode_encode_s *) handle;
1776 if (_handle == NULL || _handle->is_decode == TRUE) {
1777 image_util_error("Invalid Handle");
1778 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1780 if (_handle->image_type != IMAGE_UTIL_JPEG) {
1781 image_util_error("Wrong image format");
1782 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1784 image_util_retvm_if((quality <= 0 || quality > 100), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid quality");
1786 _handle->quality = quality;
1791 int image_util_encode_set_png_compression(image_util_encode_h handle, image_util_png_compression_e compression)
1793 int err = IMAGE_UTIL_ERROR_NONE;
1794 decode_encode_s *_handle = (decode_encode_s *) handle;
1795 mm_util_png_data *png_data;
1797 if (_handle == NULL || _handle->is_decode == TRUE) {
1798 image_util_error("Invalid Handle");
1799 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1801 if (_handle->image_type != IMAGE_UTIL_PNG) {
1802 image_util_error("Wrong image format");
1803 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1805 image_util_retvm_if((compression < IMAGE_UTIL_PNG_COMPRESSION_0 || compression > IMAGE_UTIL_PNG_COMPRESSION_9), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid compression value");
1807 png_data = (mm_util_png_data *) _handle->image_h;
1808 if (png_data == NULL) {
1809 image_util_error("Invalid png data");
1810 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1813 mm_util_png_encode_set_compression_level(png_data, compression);
1818 int image_util_encode_set_gif_frame_delay_time(image_util_encode_h handle, unsigned long long delay_time)
1820 int err = IMAGE_UTIL_ERROR_NONE;
1821 decode_encode_s *_handle = (decode_encode_s *) handle;
1822 mm_util_gif_data *gif_data;
1824 if (_handle == NULL || _handle->is_decode == TRUE) {
1825 image_util_error("Invalid Handle");
1826 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1828 if (_handle->image_type != IMAGE_UTIL_GIF) {
1829 image_util_error("Wrong image format");
1830 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1833 gif_data = (mm_util_gif_data *) _handle->image_h;
1834 if (gif_data == NULL) {
1835 image_util_error("Invalid gif data");
1836 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1838 if (gif_data->frames == NULL) {
1839 image_util_error("Error allocating gif frames.");
1840 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1842 if (_handle->image_count <= _handle->current_delay_count) {
1843 gif_data->frames = (mm_util_gif_frame_data **) realloc(gif_data->frames, (_handle->image_count + 1) * sizeof(mm_util_gif_frame_data *));
1844 if (gif_data->frames == NULL) {
1845 image_util_error("Error - OUT_OF_MEMORY");
1846 IMAGE_UTIL_SAFE_FREE(_handle);
1847 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1849 gif_data->frames[_handle->image_count] = (mm_util_gif_frame_data *) calloc(1, sizeof(mm_util_gif_frame_data));
1850 if (gif_data->frames[_handle->image_count] == NULL) {
1851 image_util_error("Error - OUT_OF_MEMORY");
1852 IMAGE_UTIL_SAFE_FREE(_handle);
1853 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1855 _handle->image_count++;
1858 mm_util_gif_encode_set_frame_delay_time(gif_data->frames[_handle->current_delay_count], delay_time);
1859 _handle->current_delay_count++;
1864 int image_util_encode_set_input_buffer(image_util_encode_h handle, const unsigned char *src_buffer)
1866 int err = IMAGE_UTIL_ERROR_NONE;
1867 decode_encode_s *_handle = (decode_encode_s *) handle;
1869 if (_handle == NULL || _handle->is_decode == TRUE) {
1870 image_util_error("Invalid Handle");
1871 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1873 if (src_buffer == NULL) {
1874 image_util_error("Invalid input buffer");
1875 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1878 _handle->src_buffer = (void *)realloc(_handle->src_buffer, (_handle->current_buffer_count + 1) * sizeof(void *));
1879 _handle->src_buffer[_handle->current_buffer_count] = (void *)src_buffer;
1881 if (_handle->image_type == IMAGE_UTIL_GIF) {
1882 mm_util_gif_data *gif_data;
1884 gif_data = (mm_util_gif_data *) _handle->image_h;
1886 if (gif_data->frames == NULL) {
1887 image_util_error("Error allocating gif frames.");
1888 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1890 if (_handle->image_count <= _handle->current_buffer_count) {
1891 gif_data->frames = (mm_util_gif_frame_data **) realloc(gif_data->frames, (_handle->image_count + 1) * sizeof(mm_util_gif_frame_data *));
1892 if (gif_data->frames == NULL) {
1893 image_util_error("Error - OUT_OF_MEMORY");
1894 IMAGE_UTIL_SAFE_FREE(_handle);
1895 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1897 gif_data->frames[_handle->image_count] = (mm_util_gif_frame_data *) calloc(1, sizeof(mm_util_gif_frame_data));
1898 if (gif_data->frames[_handle->image_count] == NULL) {
1899 image_util_error("Error - OUT_OF_MEMORY");
1900 IMAGE_UTIL_SAFE_FREE(_handle);
1901 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1903 _handle->image_count++;
1906 gif_data->frames[_handle->current_buffer_count]->data = _handle->src_buffer[_handle->current_buffer_count];
1907 _handle->current_buffer_count++;
1913 int image_util_encode_set_output_path(image_util_encode_h handle, const char *path)
1915 int err = IMAGE_UTIL_ERROR_NONE;
1916 decode_encode_s *_handle = (decode_encode_s *) handle;
1918 if (_handle == NULL || _handle->is_decode == TRUE) {
1919 image_util_error("Invalid Handle");
1920 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1922 image_util_retvm_if((path == NULL || strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
1924 if (_handle->dst_buffer)
1925 _handle->dst_buffer = NULL;
1927 _handle->path = path;
1932 int image_util_encode_set_output_buffer(image_util_encode_h handle, unsigned char **dst_buffer)
1934 int err = IMAGE_UTIL_ERROR_NONE;
1935 decode_encode_s *_handle = (decode_encode_s *) handle;
1937 if (_handle == NULL || _handle->is_decode == TRUE) {
1938 image_util_error("Invalid Handle");
1939 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1941 if (_handle->image_type == IMAGE_UTIL_BMP) {
1942 image_util_error("BMP library does not support encoding to memory");
1943 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
1945 if (dst_buffer == NULL) {
1946 image_util_error("Invalid output buffer");
1947 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1951 _handle->path = NULL;
1953 _handle->dst_buffer = (void **)dst_buffer;
1958 static int _image_util_encode_internal(decode_encode_s * _handle)
1960 int err = MM_UTIL_ERROR_NONE;
1962 switch (_handle->image_type) {
1963 case IMAGE_UTIL_JPEG:
1966 err = mm_util_jpeg_encode_to_file(_handle->path, _handle->src_buffer[0], _handle->width, _handle->height, _convert_jpeg_colorspace_tbl[_handle->colorspace], _handle->quality);
1968 err = mm_util_jpeg_encode_to_memory(_handle->dst_buffer, (int *)&(_handle->dst_size), _handle->src_buffer[0], _handle->width, _handle->height, _convert_jpeg_colorspace_tbl[_handle->colorspace], _handle->quality);
1971 case IMAGE_UTIL_PNG:
1973 mm_util_png_data *png_data;
1975 png_data = (mm_util_png_data *) _handle->image_h;
1976 if (png_data == NULL) {
1977 image_util_error("Invalid png data");
1978 return MM_UTIL_ERROR_INVALID_PARAMETER;
1982 err = mm_util_encode_to_png_file(&(_handle->src_buffer[0]), png_data, _handle->path);
1984 err = mm_util_encode_to_png_memory(&(_handle->src_buffer[0]), png_data);
1986 if (err == MM_UTIL_ERROR_NONE) {
1987 if (_handle->dst_buffer)
1988 *(_handle->dst_buffer) = png_data->data;
1989 _handle->dst_size = png_data->size;
1990 _handle->width = png_data->width;
1991 _handle->height = png_data->height;
1995 case IMAGE_UTIL_GIF:
1997 mm_util_gif_data *gif_data;
1998 void *dst_buffer = NULL;
2000 gif_data = (mm_util_gif_data *) _handle->image_h;
2001 if (gif_data == NULL) {
2002 image_util_error("Invalid gif data");
2003 return MM_UTIL_ERROR_INVALID_PARAMETER;
2005 if ((_handle->image_count > 1) && ((_handle->image_count != _handle->current_buffer_count) || (_handle->image_count != _handle->current_resolution_count) || (_handle->image_count != _handle->current_delay_count))) {
2006 image_util_error("Total frame count does not match with the data set, for animated gif encoding");
2007 return MM_UTIL_ERROR_INVALID_OPERATION;
2010 mm_util_gif_encode_set_image_count(gif_data, _handle->image_count);
2012 err = mm_util_encode_gif_to_file(gif_data, _handle->path);
2014 err = mm_util_encode_gif_to_memory(gif_data, &dst_buffer);
2016 if (err == MM_UTIL_ERROR_NONE) {
2017 if (_handle->dst_buffer)
2018 *(_handle->dst_buffer) = (unsigned char *)dst_buffer;
2019 _handle->dst_size = gif_data->size;
2020 _handle->width = gif_data->width;
2021 _handle->height = gif_data->height;
2025 case IMAGE_UTIL_BMP:
2027 mm_util_bmp_data *bmp_data;
2029 bmp_data = (mm_util_bmp_data *) _handle->image_h;
2030 if (bmp_data == NULL) {
2031 image_util_error("Invalid bmp data");
2032 return MM_UTIL_ERROR_INVALID_PARAMETER;
2035 bmp_data->data = _handle->src_buffer[0];
2037 err = mm_util_encode_bmp_to_file(bmp_data, _handle->path);
2039 image_util_error("Not yet implemented");
2040 return MM_UTIL_ERROR_INVALID_PARAMETER;
2043 if (err == MM_UTIL_ERROR_NONE) {
2044 if (_handle->dst_buffer)
2045 *(_handle->dst_buffer) = bmp_data->data;
2046 _handle->dst_size = bmp_data->size;
2047 _handle->width = bmp_data->width;
2048 _handle->height = bmp_data->height;
2053 err = MM_UTIL_ERROR_INVALID_PARAMETER;
2060 int image_util_encode_run(image_util_encode_h handle, unsigned long long *size)
2062 int err = MM_UTIL_ERROR_NONE;
2063 decode_encode_s *_handle = (decode_encode_s *) handle;
2065 if (_handle == NULL || _handle->is_decode == TRUE) {
2066 image_util_error("Invalid Handle");
2067 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2069 if ((_handle->path == NULL && _handle->dst_buffer == NULL) || _handle->src_buffer == NULL) {
2070 image_util_error("Invalid input/output");
2071 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2073 image_util_retvm_if((_image_util_check_resolution(_handle->width, _handle->height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
2075 err = _image_util_encode_internal(_handle);
2077 if (err != MM_UTIL_ERROR_NONE) {
2078 image_util_error("Error - encode run");
2079 return _convert_image_util_error_code(__func__, err);
2083 *size = _handle->dst_size;
2085 return _convert_image_util_error_code(__func__, err);
2088 gpointer _image_util_encode_thread(gpointer data)
2090 decode_encode_s *_handle = (decode_encode_s *) data;
2091 int err = MM_UTIL_ERROR_NONE;
2092 gint64 end_time = 0;
2095 image_util_error("[ERROR] - handle");
2099 while (!_handle->is_finish) {
2100 end_time = g_get_monotonic_time() + 1 * G_TIME_SPAN_SECOND;
2101 image_util_debug("waiting...");
2102 g_mutex_lock(&(_handle->thread_mutex));
2103 g_cond_wait_until(&(_handle->thread_cond), &(_handle->thread_mutex), end_time);
2104 image_util_debug("<=== get run encode thread signal");
2105 g_mutex_unlock(&(_handle->thread_mutex));
2107 if (_handle->is_finish) {
2108 image_util_debug("exit loop");
2112 err = _image_util_encode_internal(_handle);
2113 if (err == MM_UTIL_ERROR_NONE)
2114 image_util_debug("Success - encode_internal");
2116 image_util_error("Error - encode_internal");
2118 if (_handle->_encode_cb) {
2119 image_util_debug("completed_cb");
2120 _handle->is_finish = TRUE;
2121 _handle->_encode_cb->image_encode_completed_cb(_convert_image_util_error_code(__func__, err), _handle->_encode_cb->user_data, _handle->dst_size);
2125 image_util_debug("exit thread");
2130 static int _image_util_encode_create_thread(decode_encode_s * handle)
2132 int ret = MM_UTIL_ERROR_NONE;
2134 image_util_retvm_if((handle == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
2136 g_mutex_init(&(handle->thread_mutex));
2138 g_cond_init(&(handle->thread_cond));
2141 handle->thread = g_thread_new("encode_thread", (GThreadFunc) _image_util_encode_thread, (gpointer) handle);
2142 if (!handle->thread) {
2143 image_util_error("ERROR - create thread");
2144 g_mutex_clear(&(handle->thread_mutex));
2146 g_cond_clear(&(handle->thread_cond));
2147 return MM_UTIL_ERROR_INVALID_OPERATION;
2153 int image_util_encode_run_async(image_util_encode_h handle, image_util_encode_completed_cb completed_cb, void *user_data)
2155 int err = MM_UTIL_ERROR_NONE;
2156 decode_encode_s *_handle = (decode_encode_s *) handle;
2158 if (_handle == NULL || _handle->is_decode == TRUE) {
2159 image_util_error("Invalid Handle");
2160 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2162 if ((_handle->path == NULL && _handle->dst_buffer == NULL) || _handle->src_buffer == NULL) {
2163 image_util_error("Invalid input/output");
2164 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2166 image_util_retvm_if((_image_util_check_resolution(_handle->width, _handle->height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
2168 image_util_retvm_if((completed_cb == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid callback");
2170 if (_handle->_encode_cb != NULL) {
2171 IMAGE_UTIL_SAFE_FREE(_handle->_encode_cb);
2172 _handle->_encode_cb = NULL;
2174 _handle->_encode_cb = (encode_cb_s *) calloc(1, sizeof(encode_cb_s));
2175 image_util_retvm_if((_handle->_encode_cb == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Out of memory");
2177 _handle->_encode_cb->user_data = user_data;
2178 _handle->_encode_cb->image_encode_completed_cb = completed_cb;
2180 err = _image_util_encode_create_thread(_handle);
2182 return _convert_image_util_error_code(__func__, err);
2185 int image_util_encode_destroy(image_util_encode_h handle)
2187 int err = IMAGE_UTIL_ERROR_NONE;
2188 decode_encode_s *_handle = (decode_encode_s *) handle;
2190 image_util_debug("image_util_encode_destroy");
2192 if (_handle == NULL || _handle->is_decode == TRUE) {
2193 image_util_error("Invalid Handle");
2194 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2197 switch (_handle->image_type) {
2198 case IMAGE_UTIL_JPEG:
2200 mm_util_jpeg_yuv_data *jpeg_data;
2202 jpeg_data = (mm_util_jpeg_yuv_data *) _handle->image_h;
2203 if (jpeg_data == NULL) {
2204 image_util_error("Invalid jpeg data");
2205 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2207 IMAGE_UTIL_SAFE_FREE(jpeg_data);
2210 case IMAGE_UTIL_PNG:
2212 mm_util_png_data *png_data;
2214 png_data = (mm_util_png_data *) _handle->image_h;
2215 if (png_data == NULL) {
2216 image_util_error("Invalid png data");
2217 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2219 IMAGE_UTIL_SAFE_FREE(png_data);
2222 case IMAGE_UTIL_GIF:
2224 mm_util_gif_data *gif_data;
2227 gif_data = (mm_util_gif_data *) _handle->image_h;
2228 if (gif_data == NULL) {
2229 image_util_error("Invalid gif data");
2230 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2232 for (i = 1; i < _handle->image_count; i++)
2233 IMAGE_UTIL_SAFE_FREE(gif_data->frames[i]);
2234 IMAGE_UTIL_SAFE_FREE(gif_data->frames[0]);
2235 IMAGE_UTIL_SAFE_FREE(gif_data->frames);
2236 IMAGE_UTIL_SAFE_FREE(gif_data);
2239 case IMAGE_UTIL_BMP:
2241 mm_util_bmp_data *bmp_data;
2243 bmp_data = (mm_util_bmp_data *) _handle->image_h;
2244 if (bmp_data == NULL) {
2245 image_util_error("Invalid bmp data");
2246 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2248 IMAGE_UTIL_SAFE_FREE(bmp_data);
2252 err = IMAGE_UTIL_ERROR_INVALID_PARAMETER;
2256 /* g_thread_exit(handle->thread); */
2257 if (_handle->thread) {
2258 _handle->is_finish = TRUE;
2259 g_mutex_lock(&(_handle->thread_mutex));
2260 g_cond_signal(&(_handle->thread_cond));
2261 image_util_debug("===> send signal(finish) to decode_thread");
2262 g_mutex_unlock(&(_handle->thread_mutex));
2264 g_thread_join(_handle->thread);
2266 g_mutex_clear(&(_handle->thread_mutex));
2268 g_cond_clear(&(_handle->thread_cond));
2271 IMAGE_UTIL_SAFE_FREE(_handle->src_buffer);
2272 IMAGE_UTIL_SAFE_FREE(_handle);