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