src/image_util.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   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
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  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.
  15 */
  16
  17 #include <gmodule.h>
  18 #include <inttypes.h>
  19 #include <mm_util_imgp.h>
  20
  21 #include <image_util.h>
  22 #include <image_util_private.h>
  23
  24 typedef struct {
  25         mm_util_img_format image_format;
  26         media_format_mimetype_e mimetype;
  27         const char *mimetype_name;
  28 } image_format_mimetype_pair_s;
  29
  30 static const image_format_mimetype_pair_s image_format_mimetype_table[MM_UTIL_IMG_FMT_NUM] = {
  31         { MM_UTIL_IMG_FMT_YUV420,       MEDIA_FORMAT_YV12,              "MEDIA_FORMAT_YV12" },
  32         { MM_UTIL_IMG_FMT_YUV422,       MEDIA_FORMAT_422P,              "MEDIA_FORMAT_422P" },
  33         { MM_UTIL_IMG_FMT_I420,         MEDIA_FORMAT_I420,              "MEDIA_FORMAT_I420" },
  34         { MM_UTIL_IMG_FMT_NV12,         -1,                                             "Not support" },
  35         { MM_UTIL_IMG_FMT_UYVY,         MEDIA_FORMAT_UYVY,              "MEDIA_FORMAT_UYVY" },
  36         { MM_UTIL_IMG_FMT_YUYV,         MEDIA_FORMAT_YUYV,              "MEDIA_FORMAT_YUYV" },
  37         { MM_UTIL_IMG_FMT_RGB565,       MEDIA_FORMAT_RGB565,    "MEDIA_FORMAT_RGB565" },
  38         { MM_UTIL_IMG_FMT_RGB888,       MEDIA_FORMAT_RGB888,    "MEDIA_FORMAT_RGB888" },
  39         { MM_UTIL_IMG_FMT_ARGB8888,     MEDIA_FORMAT_ARGB,              "MEDIA_FORMAT_ARGB" },
  40         { MM_UTIL_IMG_FMT_BGRA8888,     MEDIA_FORMAT_BGRA,              "MEDIA_FORMAT_BGRA" },
  41         { MM_UTIL_IMG_FMT_RGBA8888,     MEDIA_FORMAT_RGBA,              "MEDIA_FORMAT_RGBA" },
  42         { MM_UTIL_IMG_FMT_BGRX8888,     -1,                                             "Not support" },
  43         { MM_UTIL_IMG_FMT_NV12_TILED,   MEDIA_FORMAT_NV12T,     "MEDIA_FORMAT_NV12T" },
  44         { MM_UTIL_IMG_FMT_NV16,         MEDIA_FORMAT_NV16,              "MEDIA_FORMAT_NV16" },
  45         { MM_UTIL_IMG_FMT_NV61,         -1,                                             "Not support" }
  46 };
  47
  48 static media_format_mimetype_e __image_format_to_mimetype(mm_util_img_format format)
  49 {
  50         unsigned int i = 0;
  51         media_format_mimetype_e mimetype = -1;
  52
  53         for (i = 0; i < MM_UTIL_IMG_FMT_NUM; i++) {
  54                 if (image_format_mimetype_table[i].image_format == format) {
  55                         mimetype = image_format_mimetype_table[i].mimetype;
  56                         break;
  57                 }
  58         }
  59
  60         image_util_debug("imgp fmt: %d mimetype fmt: %s", format, image_format_mimetype_table[i].mimetype_name);
  61
  62         return mimetype;
  63 }
  64
  65 static mm_util_img_format __mimetype_to_image_format(media_format_mimetype_e mimetype)
  66 {
  67         unsigned int i = 0;
  68         mm_util_img_format format = -1;
  69
  70         for (i = 0; i < MM_UTIL_IMG_FMT_NUM; i++) {
  71                 if (image_format_mimetype_table[i].mimetype == mimetype) {
  72                         format = image_format_mimetype_table[i].image_format;
  73                         break;
  74                 }
  75         }
  76
  77         image_util_debug("mimetype: %s imgp fmt: %d", image_format_mimetype_table[i].mimetype_name, format);
  78
  79         return format;
  80 }
  81
  82 static int __create_media_format(media_format_mimetype_e mimetype, unsigned int width, unsigned int height, media_format_h *new_fmt)
  83 {
  84         int err = MEDIA_FORMAT_ERROR_NONE;
  85
  86         image_util_retvm_if((new_fmt == NULL) || (width == 0) || (height == 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
  87
  88         err = media_format_create(new_fmt);
  89         if (err != MEDIA_FORMAT_ERROR_NONE) {
  90                 image_util_error("media_format_make_writable failed (%d)", err);
  91                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
  92         }
  93
  94         err = media_format_set_video_mime(*new_fmt, mimetype);
  95         if (err != MEDIA_FORMAT_ERROR_NONE) {
  96                 media_format_unref(*new_fmt);
  97                 image_util_error("media_format_set_video_mime failed (%d)", err);
  98                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
  99         }
 100
 101         err = media_format_set_video_width(*new_fmt, width);
 102         if (err != MEDIA_FORMAT_ERROR_NONE) {
 103                 media_format_unref(*new_fmt);
 104                 image_util_error("media_format_set_video_width failed (%d)", err);
 105                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 106         }
 107
 108         err = media_format_set_video_height(*new_fmt, height);
 109         if (err != MEDIA_FORMAT_ERROR_NONE) {
 110                 media_format_unref(*new_fmt);
 111                 image_util_error("media_format_set_video_height failed (%d)", err);
 112                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 113         }
 114
 115         return IMAGE_UTIL_ERROR_NONE;
 116 }
 117
 118 static int _image_util_packet_to_image(media_packet_h packet, mm_util_color_image_h *color_image)
 119 {
 120         int err = IMAGE_UTIL_ERROR_NONE;
 121         media_format_mimetype_e mimetype = 0;
 122         int width = 0, height = 0;
 123         uint64_t size = 0;
 124         void *ptr = NULL;
 125         media_format_h fmt = NULL;
 126
 127         image_util_retvm_if(((packet == NULL) || (color_image == NULL)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid parameter");
 128
 129         err = media_packet_get_format(packet, &fmt);
 130         if (err != MEDIA_PACKET_ERROR_NONE) {
 131                 image_util_error("media_packet_get_format failed (%d)", err);
 132                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 133         }
 134
 135         err = media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
 136         if (err != MEDIA_FORMAT_ERROR_NONE) {
 137                 image_util_error("media_packet_get_format failed (%d)", err);
 138                 media_format_unref(fmt);
 139                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 140         }
 141         media_format_unref(fmt);
 142
 143         err = media_packet_get_buffer_size(packet, &size);
 144         if (err != MEDIA_PACKET_ERROR_NONE) {
 145                 image_util_error("media_packet_get_buffer_size failed (%d)", err);
 146                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 147         }
 148
 149         if (size) {
 150                 err = media_packet_get_buffer_data_ptr(packet, &ptr);
 151                 if (err != MM_UTIL_ERROR_NONE) {
 152                         image_util_error("media_packet_get_buffer_data_ptr failed (%d)", err);
 153                         return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 154                 }
 155         }
 156
 157         image_util_debug("[Fotmat: %u] W x H : %d x %d", mimetype, width, height);
 158         if ((width == 0) || (height == 0) || (size == 0) || (ptr == NULL)) {
 159                 image_util_error("Invalid source packet");
 160                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 161         }
 162         image_util_debug("_image_util_packet_to_image succeed");
 163
 164         err = mm_util_create_color_image(color_image);
 165         if (err != MM_UTIL_ERROR_NONE) {
 166                 image_util_error("Error - Run transform (%d)", err);
 167                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 168         }
 169         image_util_debug("_image_util_packet_to_image succeed");
 170
 171         err = mm_util_set_color_image(*color_image, width, height, __mimetype_to_image_format(mimetype), ptr, size);
 172         if (err != MM_UTIL_ERROR_NONE) {
 173                 image_util_error("mm_util_push_request_image failed (%d)", err);
 174                 mm_util_destroy_color_image(*color_image);
 175                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 176         }
 177
 178         image_util_debug("_image_util_packet_to_image succeed");
 179
 180         return IMAGE_UTIL_ERROR_NONE;
 181 }
 182
 183 static int _image_util_image_to_packet(mm_util_color_image_h image, media_packet_h *packet)
 184 {
 185         int err = IMAGE_UTIL_ERROR_NONE;
 186         mm_util_img_format format = 0;
 187         int width = 0, height = 0;
 188         void *buffer = NULL;
 189         size_t buffer_size = 0;
 190         media_format_h fmt = NULL;
 191         void *packet_ptr = NULL;
 192         uint64_t packet_size = 0;
 193         size_t size = 0;
 194
 195         err = mm_util_get_color_image(image, &width, &height, &format, &buffer, &buffer_size);
 196         if (err != MM_UTIL_ERROR_NONE) {
 197                 image_util_error("mm_util_get_color_image failed (%d)", err);
 198                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 199         }
 200
 201         err = __create_media_format(__image_format_to_mimetype(format), width, height, &fmt);
 202         if (err != IMAGE_UTIL_ERROR_NONE) {
 203                 image_util_error("mm_util_push_request_image failed (%d)", err);
 204                 return err;
 205         }
 206
 207         err = media_packet_create_alloc(fmt, NULL, NULL, packet);
 208         if (err != MEDIA_PACKET_ERROR_NONE) {
 209                 image_util_error("media_packet_create_alloc failed (%d)", err);
 210                 media_format_unref(fmt);
 211                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 212         }
 213
 214         err = media_packet_get_buffer_size(*packet, &packet_size);
 215         if (err != MEDIA_PACKET_ERROR_NONE) {
 216                 image_util_error("media_packet_get_buffer_size failed (%d)", err);
 217                 media_packet_destroy(*packet);
 218                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 219         }
 220
 221         err = media_packet_get_buffer_data_ptr(*packet, &packet_ptr);
 222         if (err != MEDIA_PACKET_ERROR_NONE) {
 223                 image_util_error("media_packet_get_buffer_data_ptr failed");
 224                 media_packet_destroy(*packet);
 225                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 226         }
 227
 228         if (packet_ptr == NULL || packet_size == 0) {
 229                 image_util_error("media_packet creation failed (%p, %" PRIu64 ")", packet_ptr, packet_size);
 230                 media_packet_destroy(*packet);
 231                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 232         }
 233         image_util_debug("Success - media_packet is created (%p, %" PRIu64 ")", packet_ptr, packet_size);
 234
 235         if ((uint64_t)buffer_size < packet_size) {
 236                 size = (size_t)buffer_size;
 237         } else {
 238                 size = (size_t)packet_size;
 239         }
 240
 241         image_util_debug("Size: result(%u) media_packet(%" PRIu64 ") copied(%zu)", buffer_size, packet_size, size);
 242         memcpy(packet_ptr, buffer, size);
 243
 244         image_util_debug("_image_util_image_to_packet succeed");
 245
 246         return IMAGE_UTIL_ERROR_NONE;
 247 }
 248
 249 static void _image_util_transform_completed_cb(mm_util_color_image_h raw_image, int error, void *user_data)
 250 {
 251         int err = IMAGE_UTIL_ERROR_NONE;
 252         image_util_cb_s *_util_cb = (image_util_cb_s *) user_data;
 253         media_packet_h packet = NULL;
 254
 255         if ((_util_cb != NULL) && (_util_cb->completed_cb != NULL)) {
 256                 err = _image_util_image_to_packet(raw_image, &packet);
 257                 if (err != MM_UTIL_ERROR_NONE) {
 258                         image_util_error("_image_util_image_to_packet failed (%d)", err);
 259                         _util_cb->completed_cb(NULL, err, _util_cb->user_data);
 260                 } else {
 261                         _util_cb->completed_cb(&packet, _image_error_capi(ERR_TYPE_TRANSFORM, error), _util_cb->user_data);
 262                 }
 263         }
 264
 265         return;
 266 }
 267
 268 static int _image_util_create_transform_handle(transformation_s * handle)
 269 {
 270         int err = MM_UTIL_ERROR_NONE;
 271         mm_util_imgp_h image_h;
 272
 273         err = mm_util_create(&image_h);
 274         if (err != MM_UTIL_ERROR_NONE) {
 275                 image_util_error("Error - mm_util_create");
 276                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 277         }
 278
 279         handle->image_h = image_h;
 280
 281         return IMAGE_UTIL_ERROR_NONE;
 282 }
 283
 284 int image_util_foreach_supported_jpeg_colorspace(image_util_supported_jpeg_colorspace_cb callback, void *user_data)
 285 {
 286         int idx = 0;
 287
 288         DEPRECATION_LOGW("image_util_foreach_supported_jpeg_colorspace()", "image_util_foreach_supported_colorspace()");
 289
 290         image_util_retvm_if((callback == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "callback is null");
 291
 292         /* RGB has higher precedence than YUV */
 293         for (idx = (int)(NUM_OF_COLORSPACE - 1); idx >= 0; idx--) {
 294                 if (is_supported_colorspace(idx, IMAGE_UTIL_JPEG))
 295                         if (false == callback(idx, user_data))
 296                                 return IMAGE_UTIL_ERROR_NONE;
 297
 298         }
 299
 300         return IMAGE_UTIL_ERROR_NONE;
 301 }
 302
 303 int image_util_transform_create(transformation_h * handle)
 304 {
 305         int err = MM_UTIL_ERROR_NONE;
 306
 307         image_util_debug("image_util_create");
 308
 309         image_util_retvm_if((handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 310
 311         transformation_s *_handle = (transformation_s *) calloc(1, sizeof(transformation_s));
 312         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 313
 314         _handle->colorspace = _NOT_SUPPORTED_COLORSPACE;
 315         _handle->_util_cb = NULL;
 316         _handle->image_h = NULL;
 317         _handle->set_convert = false;
 318         _handle->set_resize = false;
 319         _handle->set_rotate = false;
 320         _handle->set_crop = false;
 321
 322         err = _image_util_create_transform_handle(_handle);
 323         if (err != MM_UTIL_ERROR_NONE) {
 324                 image_util_error("Error - create transform handle");
 325                 IMAGE_UTIL_SAFE_FREE(_handle);
 326                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 327         }
 328
 329         *handle = (transformation_h) _handle;
 330
 331         return IMAGE_UTIL_ERROR_NONE;
 332 }
 333
 334 int image_util_transform_set_hardware_acceleration(transformation_h handle, bool mode)
 335 {
 336         transformation_s *_handle = (transformation_s *) handle;
 337
 338         image_util_warning("DEPRECATION WARNING: image_util_transform_set_hardware_acceleration() is deprecated and will be removed from next release.");
 339         image_util_debug("Set hardware_acceleration %d", mode);
 340
 341         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 342 #ifndef ENABLE_HW_ACCELERATION
 343         image_util_retvm_if((mode == true), IMAGE_UTIL_ERROR_NOT_SUPPORTED, "hardware acceleration is not supported");
 344 #endif
 345
 346         image_util_debug("Set hardware_acceleration %d", mode);
 347
 348         return IMAGE_UTIL_ERROR_NONE;
 349 }
 350
 351 int image_util_transform_set_colorspace(transformation_h handle, image_util_colorspace_e colorspace)
 352 {
 353         int err = MM_UTIL_ERROR_NONE;
 354         transformation_s *_handle = (transformation_s *) handle;
 355
 356         image_util_debug("Set colorspace_convert_info [%d]", colorspace);
 357
 358         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 359
 360         err = mm_util_set_colorspace_convert(_handle->image_h, colorspace);
 361         if (err != MM_UTIL_ERROR_NONE) {
 362                 image_util_error("Error - Set colorspace convert");
 363                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 364         }
 365
 366         _handle->colorspace = colorspace;
 367         _handle->set_convert = true;
 368
 369         return IMAGE_UTIL_ERROR_NONE;
 370 }
 371
 372 int image_util_transform_set_resolution(transformation_h handle, unsigned int width, unsigned int height)
 373 {
 374         int err = MM_UTIL_ERROR_NONE;
 375         transformation_s *_handle = (transformation_s *) handle;
 376
 377         image_util_debug("Set resize_info w[%d] h[%d]", width, height);
 378
 379         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 380         image_util_retvm_if((_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
 381         image_util_retvm_if((_image_util_check_resolution(width, height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
 382
 383         err = mm_util_set_resolution(_handle->image_h, width, height);
 384         if (err != MM_UTIL_ERROR_NONE) {
 385                 image_util_error("Error - Set resolution");
 386                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 387         }
 388         _handle->width = width;
 389         _handle->height = height;
 390         _handle->set_resize = true;
 391
 392         return IMAGE_UTIL_ERROR_NONE;
 393 }
 394
 395 int image_util_transform_set_rotation(transformation_h handle, image_util_rotation_e rotation)
 396 {
 397         int err = MM_UTIL_ERROR_NONE;
 398         transformation_s *_handle = (transformation_s *) handle;
 399
 400         image_util_debug("Set rotate_info [%d]", rotation);
 401
 402         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 403
 404         err = mm_util_set_rotation(_handle->image_h, rotation);
 405         if (err != MM_UTIL_ERROR_NONE) {
 406                 image_util_error("Error - Set rotation");
 407                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 408         }
 409         _handle->rotation = rotation;
 410         _handle->set_rotate = true;
 411
 412         return IMAGE_UTIL_ERROR_NONE;
 413 }
 414
 415 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)
 416 {
 417         int err = MM_UTIL_ERROR_NONE;
 418         transformation_s *_handle = (transformation_s *) handle;
 419         int dest_width;
 420         int dest_height;
 421
 422         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 423         image_util_retvm_if((_handle->set_resize), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
 424
 425         dest_width = end_x - start_x;
 426         dest_height = end_y - start_y;
 427
 428         image_util_debug("Set crop_info x[%d] y[%d] w[%d] h[%d]", start_x, start_y, dest_width, dest_height);
 429
 430         image_util_retvm_if((_image_util_check_resolution(dest_width, dest_height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dest resolution");
 431         err = mm_util_set_crop_area(_handle->image_h, start_x, start_y, end_x, end_y);
 432         if (err != MM_UTIL_ERROR_NONE) {
 433                 image_util_error("Error - Set crop area");
 434                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 435         }
 436         _handle->start_x = start_x;
 437         _handle->start_y = start_y;
 438         _handle->end_x = end_x;
 439         _handle->end_y = end_y;
 440         _handle->set_crop = true;
 441
 442         return IMAGE_UTIL_ERROR_NONE;
 443 }
 444
 445 int image_util_transform_get_colorspace(transformation_h handle, image_util_colorspace_e * colorspace)
 446 {
 447         transformation_s *_handle = (transformation_s *) handle;
 448
 449         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 450         image_util_retvm_if((colorspace == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "colorspace parameter error");
 451
 452         if (!_handle->set_convert) {
 453                 image_util_error("Did not set colorspace before");
 454                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 455         }
 456
 457         image_util_debug("Get colorspace_convert_info [%d]", _handle->colorspace);
 458
 459         *colorspace = _handle->colorspace;
 460
 461         return IMAGE_UTIL_ERROR_NONE;
 462 }
 463
 464 int image_util_transform_get_resolution(transformation_h handle, unsigned int *width, unsigned int *height)
 465 {
 466         transformation_s *_handle = (transformation_s *) handle;
 467
 468         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 469         image_util_retvm_if((width == NULL || height == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "width or height parameter error");
 470
 471         if (!_handle->set_resize) {
 472                 image_util_error("Did not set resolution before");
 473                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 474         }
 475
 476         image_util_debug("Get resize_info w[%ui] h[%ui]", _handle->width, _handle->height);
 477
 478         *width = _handle->width;
 479         *height = _handle->height;
 480
 481         return IMAGE_UTIL_ERROR_NONE;
 482 }
 483
 484 int image_util_transform_get_rotation(transformation_h handle, image_util_rotation_e * rotation)
 485 {
 486         transformation_s *_handle = (transformation_s *) handle;
 487
 488         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 489         image_util_retvm_if((rotation == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "rotation parameter error");
 490
 491         if (!_handle->set_rotate) {
 492                 image_util_error("Did not set rotation before");
 493                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 494         }
 495
 496         image_util_debug("Get rotate_info [%d]", _handle->rotation);
 497
 498         *rotation = _handle->rotation;
 499
 500         return IMAGE_UTIL_ERROR_NONE;
 501 }
 502
 503 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)
 504 {
 505         transformation_s *_handle = (transformation_s *) handle;
 506
 507         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 508         image_util_retvm_if((start_x == NULL || start_y == NULL || end_x == NULL || end_y == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "crop area parameter error");
 509
 510         if (!_handle->set_crop) {
 511                 image_util_error("Did not set crop area before");
 512                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 513         }
 514
 515         *start_x = _handle->start_x;
 516         *start_y = _handle->start_y;
 517         *end_x = _handle->end_x;
 518         *end_y = _handle->end_y;
 519
 520         return IMAGE_UTIL_ERROR_NONE;
 521 }
 522
 523 int image_util_transform_run(transformation_h handle, media_packet_h src, image_util_transform_completed_cb completed_cb, void *user_data)
 524 {
 525         int err = MM_UTIL_ERROR_NONE;
 526         transformation_s *_handle = (transformation_s *) handle;
 527
 528         image_util_debug("image_util_transform");
 529
 530         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 531         image_util_retvm_if((completed_cb == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid callback");
 532         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid source");
 533         image_util_retvm_if((!_handle->set_convert && !_handle->set_resize && !_handle->set_rotate && !_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid transform");
 534
 535         mm_util_color_image_h color_image = NULL;
 536
 537         err = _image_util_packet_to_image(src, &color_image);
 538         image_util_retvm_if((err != IMAGE_UTIL_ERROR_NONE), err, "_image_util_packet_to_image failed");
 539
 540         _handle->_util_cb = (image_util_cb_s *) calloc(1, sizeof(image_util_cb_s));
 541         if (_handle->_util_cb == NULL) {
 542                 image_util_error("Memory allocation failed");
 543                 mm_util_destroy_color_image(color_image);
 544                 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
 545         }
 546         _handle->_util_cb->user_data = user_data;
 547         _handle->_util_cb->completed_cb = completed_cb;
 548
 549         err = mm_util_transform(_handle->image_h, color_image, (mm_util_completed_callback) _image_util_transform_completed_cb, (void *)_handle->_util_cb);
 550         if (err != MM_UTIL_ERROR_NONE) {
 551                 image_util_error("Error - Run transform (%d)", err);
 552                 mm_util_destroy_color_image(color_image);
 553                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 554         }
 555
 556         return IMAGE_UTIL_ERROR_NONE;
 557 }
 558
 559 int image_util_transform_destroy(transformation_h handle)
 560 {
 561         int err = MM_UTIL_ERROR_NONE;
 562         transformation_s *_handle = (transformation_s *) handle;
 563
 564         image_util_debug("image_util_destroy");
 565
 566         if (_handle == NULL) {
 567                 image_util_error("Invalid Handle");
 568                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 569         }
 570
 571         err = mm_util_destroy(_handle->image_h);
 572
 573         IMAGE_UTIL_SAFE_FREE(_handle->_util_cb);
 574         IMAGE_UTIL_SAFE_FREE(_handle);
 575
 576         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 577 }
 578
 579 int image_util_calculate_buffer_size(int width, int height, image_util_colorspace_e colorspace, unsigned int *size)
 580 {
 581         int err = MM_UTIL_ERROR_NONE;
 582
 583         image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
 584         image_util_retvm_if((width <= 0 || height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid width or Invalid height");
 585         image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
 586
 587         err = mm_util_get_image_size(TYPECAST_COLOR(colorspace), width, height, size);
 588
 589         return _image_error_capi(ERR_TYPE_COMMON, err);
 590 }
 591
 592 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)
 593 {
 594         int ret = MM_UTIL_ERROR_NONE;
 595
 596         image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
 597
 598         GModule *module = NULL;
 599         ModuleFunc mmutil_imgcv_module_func = NULL;
 600         module = g_module_open(PATH_MMUTIL_IMGCV_LIB, G_MODULE_BIND_LAZY);
 601         image_util_retvm_if((module == NULL), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "fail to open module");
 602
 603         g_module_symbol(module, IMGCV_FUNC_NAME, (gpointer *)&mmutil_imgcv_module_func);
 604         if (!mmutil_imgcv_module_func)
 605                 g_module_close(module);
 606
 607         image_util_retvm_if((mmutil_imgcv_module_func == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "fail to get symbol");
 608
 609         unsigned char r_color, g_color, b_color;
 610         ret = mmutil_imgcv_module_func((void *)image_buffer, width, height, &r_color, &g_color, &b_color);
 611
 612         *rgb_r = r_color;
 613         *rgb_g = g_color;
 614         *rgb_b = b_color;
 615
 616         if (module) {
 617                 g_module_close(module);
 618                 module = NULL;
 619         }
 620
 621         return _image_error_capi(ERR_TYPE_COMMON, ret);
 622 }
 623
 624 int image_util_foreach_supported_colorspace(image_util_type_e image_type, image_util_supported_colorspace_cb callback, void *user_data)
 625 {
 626         int idx = 0;
 627
 628         IMAGE_UTIL_TYPE_CHECK(image_type);
 629         image_util_retvm_if((callback == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "callback is null");
 630
 631         for (idx = (int)(NUM_OF_COLORSPACE - 1); idx >= 0; idx--) {
 632                 if (is_supported_colorspace(idx, image_type))
 633                         if (false == callback(idx, user_data))
 634                                 return IMAGE_UTIL_ERROR_NONE;
 635
 636         }
 637
 638         return IMAGE_UTIL_ERROR_NONE;
 639 }