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_transform_create(transformation_h * handle)
 277 {
 278         int err = MM_UTIL_ERROR_NONE;
 279
 280         image_util_debug("image_util_create");
 281
 282         image_util_retvm_if((handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 283
 284         transformation_s *_handle = (transformation_s *) calloc(1, sizeof(transformation_s));
 285         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 286
 287         _handle->colorspace = _NOT_SUPPORTED_COLORSPACE;
 288         _handle->_util_cb = NULL;
 289         _handle->image_h = NULL;
 290         _handle->set_convert = false;
 291         _handle->set_resize = false;
 292         _handle->set_rotate = false;
 293         _handle->set_crop = false;
 294
 295         err = _image_util_create_transform_handle(_handle);
 296         if (err != MM_UTIL_ERROR_NONE) {
 297                 image_util_error("Error - create transform handle");
 298                 IMAGE_UTIL_SAFE_FREE(_handle);
 299                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 300         }
 301
 302         *handle = (transformation_h) _handle;
 303
 304         return IMAGE_UTIL_ERROR_NONE;
 305 }
 306
 307 int image_util_transform_set_hardware_acceleration(transformation_h handle, bool mode)
 308 {
 309         transformation_s *_handle = (transformation_s *) handle;
 310
 311         image_util_warning("DEPRECATION WARNING: image_util_transform_set_hardware_acceleration() is deprecated and will be removed from next release.");
 312         image_util_debug("Set hardware_acceleration %d", mode);
 313
 314         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 315 #ifndef ENABLE_HW_ACCELERATION
 316         image_util_retvm_if((mode == true), IMAGE_UTIL_ERROR_NOT_SUPPORTED, "hardware acceleration is not supported");
 317 #endif
 318
 319         image_util_debug("Set hardware_acceleration %d", mode);
 320
 321         return IMAGE_UTIL_ERROR_NONE;
 322 }
 323
 324 int image_util_transform_set_colorspace(transformation_h handle, image_util_colorspace_e colorspace)
 325 {
 326         int err = MM_UTIL_ERROR_NONE;
 327         transformation_s *_handle = (transformation_s *) handle;
 328
 329         image_util_debug("Set colorspace_convert_info [%d]", colorspace);
 330
 331         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 332
 333         err = mm_util_set_colorspace_convert(_handle->image_h, colorspace);
 334         if (err != MM_UTIL_ERROR_NONE) {
 335                 image_util_error("Error - Set colorspace convert");
 336                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 337         }
 338
 339         _handle->colorspace = colorspace;
 340         _handle->set_convert = true;
 341
 342         return IMAGE_UTIL_ERROR_NONE;
 343 }
 344
 345 int image_util_transform_set_resolution(transformation_h handle, unsigned int width, unsigned int height)
 346 {
 347         int err = MM_UTIL_ERROR_NONE;
 348         transformation_s *_handle = (transformation_s *) handle;
 349
 350         image_util_debug("Set resize_info w[%d] h[%d]", width, height);
 351
 352         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 353         image_util_retvm_if((_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
 354         image_util_retvm_if((_image_util_check_resolution(width, height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid resolution");
 355
 356         err = mm_util_set_resolution(_handle->image_h, width, height);
 357         if (err != MM_UTIL_ERROR_NONE) {
 358                 image_util_error("Error - Set resolution");
 359                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 360         }
 361         _handle->width = width;
 362         _handle->height = height;
 363         _handle->set_resize = true;
 364
 365         return IMAGE_UTIL_ERROR_NONE;
 366 }
 367
 368 int image_util_transform_set_rotation(transformation_h handle, image_util_rotation_e rotation)
 369 {
 370         int err = MM_UTIL_ERROR_NONE;
 371         transformation_s *_handle = (transformation_s *) handle;
 372
 373         image_util_debug("Set rotate_info [%d]", rotation);
 374
 375         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 376
 377         err = mm_util_set_rotation(_handle->image_h, rotation);
 378         if (err != MM_UTIL_ERROR_NONE) {
 379                 image_util_error("Error - Set rotation");
 380                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 381         }
 382         _handle->rotation = rotation;
 383         _handle->set_rotate = true;
 384
 385         return IMAGE_UTIL_ERROR_NONE;
 386 }
 387
 388 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)
 389 {
 390         int err = MM_UTIL_ERROR_NONE;
 391         transformation_s *_handle = (transformation_s *) handle;
 392         int dest_width;
 393         int dest_height;
 394
 395         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 396         image_util_retvm_if((_handle->set_resize), IMAGE_UTIL_ERROR_INVALID_OPERATION, "Crop and Resize can't do at the same time");
 397
 398         dest_width = end_x - start_x;
 399         dest_height = end_y - start_y;
 400
 401         image_util_debug("Set crop_info x[%d] y[%d] w[%d] h[%d]", start_x, start_y, dest_width, dest_height);
 402
 403         image_util_retvm_if((_image_util_check_resolution(dest_width, dest_height) == false), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dest resolution");
 404         err = mm_util_set_crop_area(_handle->image_h, start_x, start_y, end_x, end_y);
 405         if (err != MM_UTIL_ERROR_NONE) {
 406                 image_util_error("Error - Set crop area");
 407                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 408         }
 409         _handle->start_x = start_x;
 410         _handle->start_y = start_y;
 411         _handle->end_x = end_x;
 412         _handle->end_y = end_y;
 413         _handle->set_crop = true;
 414
 415         return IMAGE_UTIL_ERROR_NONE;
 416 }
 417
 418 int image_util_transform_get_colorspace(transformation_h handle, image_util_colorspace_e * colorspace)
 419 {
 420         transformation_s *_handle = (transformation_s *) handle;
 421
 422         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 423         image_util_retvm_if((colorspace == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "colorspace parameter error");
 424
 425         if (!_handle->set_convert) {
 426                 image_util_error("Did not set colorspace before");
 427                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 428         }
 429
 430         image_util_debug("Get colorspace_convert_info [%d]", _handle->colorspace);
 431
 432         *colorspace = _handle->colorspace;
 433
 434         return IMAGE_UTIL_ERROR_NONE;
 435 }
 436
 437 int image_util_transform_get_resolution(transformation_h handle, unsigned int *width, unsigned int *height)
 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((width == NULL || height == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "width or height parameter error");
 443
 444         if (!_handle->set_resize) {
 445                 image_util_error("Did not set resolution before");
 446                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 447         }
 448
 449         image_util_debug("Get resize_info w[%ui] h[%ui]", _handle->width, _handle->height);
 450
 451         *width = _handle->width;
 452         *height = _handle->height;
 453
 454         return IMAGE_UTIL_ERROR_NONE;
 455 }
 456
 457 int image_util_transform_get_rotation(transformation_h handle, image_util_rotation_e * rotation)
 458 {
 459         transformation_s *_handle = (transformation_s *) handle;
 460
 461         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 462         image_util_retvm_if((rotation == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "rotation parameter error");
 463
 464         if (!_handle->set_rotate) {
 465                 image_util_error("Did not set rotation before");
 466                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 467         }
 468
 469         image_util_debug("Get rotate_info [%d]", _handle->rotation);
 470
 471         *rotation = _handle->rotation;
 472
 473         return IMAGE_UTIL_ERROR_NONE;
 474 }
 475
 476 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)
 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((start_x == NULL || start_y == NULL || end_x == NULL || end_y == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "crop area parameter error");
 482
 483         if (!_handle->set_crop) {
 484                 image_util_error("Did not set crop area before");
 485                 return IMAGE_UTIL_ERROR_INVALID_OPERATION;
 486         }
 487
 488         *start_x = _handle->start_x;
 489         *start_y = _handle->start_y;
 490         *end_x = _handle->end_x;
 491         *end_y = _handle->end_y;
 492
 493         return IMAGE_UTIL_ERROR_NONE;
 494 }
 495
 496 int image_util_transform_run(transformation_h handle, media_packet_h src, image_util_transform_completed_cb completed_cb, void *user_data)
 497 {
 498         int err = MM_UTIL_ERROR_NONE;
 499         transformation_s *_handle = (transformation_s *) handle;
 500
 501         image_util_debug("image_util_transform");
 502
 503         image_util_retvm_if((_handle == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 504         image_util_retvm_if((completed_cb == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid callback");
 505         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid source");
 506         image_util_retvm_if((!_handle->set_convert && !_handle->set_resize && !_handle->set_rotate && !_handle->set_crop), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid transform");
 507
 508         mm_util_color_image_h color_image = NULL;
 509
 510         err = _image_util_packet_to_image(src, &color_image);
 511         image_util_retvm_if((err != IMAGE_UTIL_ERROR_NONE), err, "_image_util_packet_to_image failed");
 512
 513         _handle->_util_cb = (image_util_cb_s *) calloc(1, sizeof(image_util_cb_s));
 514         if (_handle->_util_cb == NULL) {
 515                 image_util_error("Memory allocation failed");
 516                 mm_util_destroy_color_image(color_image);
 517                 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
 518         }
 519         _handle->_util_cb->user_data = user_data;
 520         _handle->_util_cb->completed_cb = completed_cb;
 521
 522         err = mm_util_transform(_handle->image_h, color_image, (mm_util_completed_callback) _image_util_transform_completed_cb, (void *)_handle->_util_cb);
 523         if (err != MM_UTIL_ERROR_NONE) {
 524                 image_util_error("Error - Run transform (%d)", err);
 525                 mm_util_destroy_color_image(color_image);
 526                 return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 527         }
 528
 529         return IMAGE_UTIL_ERROR_NONE;
 530 }
 531
 532 int image_util_transform_destroy(transformation_h handle)
 533 {
 534         int err = MM_UTIL_ERROR_NONE;
 535         transformation_s *_handle = (transformation_s *) handle;
 536
 537         image_util_debug("image_util_destroy");
 538
 539         if (_handle == NULL) {
 540                 image_util_error("Invalid Handle");
 541                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         err = mm_util_destroy(_handle->image_h);
 545
 546         IMAGE_UTIL_SAFE_FREE(_handle->_util_cb);
 547         IMAGE_UTIL_SAFE_FREE(_handle);
 548
 549         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 550 }
 551
 552 int image_util_calculate_buffer_size(int width, int height, image_util_colorspace_e colorspace, unsigned int *size)
 553 {
 554         int err = MM_UTIL_ERROR_NONE;
 555         size_t size_ptr = 0;
 556
 557         image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
 558         image_util_retvm_if((width <= 0 || height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid width or Invalid height");
 559         image_util_retvm_if((size == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "size is null");
 560
 561         err = mm_util_get_image_size(TYPECAST_COLOR(colorspace), width, height, &size_ptr);
 562
 563         *size = (unsigned int)size_ptr;
 564
 565         return _image_error_capi(ERR_TYPE_COMMON, err);
 566 }
 567
 568 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)
 569 {
 570         int ret = MM_UTIL_ERROR_NONE;
 571
 572         image_util_retvm_if((image_buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "image_buffer is null");
 573
 574         GModule *module = NULL;
 575         ModuleFunc mmutil_imgcv_module_func = NULL;
 576         module = g_module_open(PATH_MMUTIL_IMGCV_LIB, G_MODULE_BIND_LAZY);
 577         image_util_retvm_if((module == NULL), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "fail to open module");
 578
 579         g_module_symbol(module, IMGCV_FUNC_NAME, (gpointer *)&mmutil_imgcv_module_func);
 580         if (!mmutil_imgcv_module_func)
 581                 g_module_close(module);
 582
 583         image_util_retvm_if((mmutil_imgcv_module_func == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "fail to get symbol");
 584
 585         unsigned char r_color, g_color, b_color;
 586         ret = mmutil_imgcv_module_func((void *)image_buffer, width, height, &r_color, &g_color, &b_color);
 587
 588         *rgb_r = r_color;
 589         *rgb_g = g_color;
 590         *rgb_b = b_color;
 591
 592         if (module) {
 593                 g_module_close(module);
 594                 module = NULL;
 595         }
 596
 597         return _image_error_capi(ERR_TYPE_COMMON, ret);
 598 }
 599
 600 int image_util_foreach_supported_colorspace(image_util_type_e image_type, image_util_supported_colorspace_cb callback, void *user_data)
 601 {
 602         int idx = 0;
 603
 604         IMAGE_UTIL_TYPE_CHECK(image_type);
 605         image_util_retvm_if((callback == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "callback is null");
 606
 607         for (idx = (int)(NUM_OF_COLORSPACE - 1); idx >= 0; idx--) {
 608                 if (is_supported_colorspace(idx, image_type))
 609                         if (false == callback(idx, user_data))
 610                                 return IMAGE_UTIL_ERROR_NONE;
 611
 612         }
 613
 614         return IMAGE_UTIL_ERROR_NONE;
 615 }