src/image_util_internal.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 <image_util.h>
  18 #include <image_util_internal.h>
  19 #include <image_util_private.h>
  20
  21 #include <mm_util_imgp.h>
  22 #include <mm_util_gif.h>
  23
  24 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)
  25 {
  26         int err = MM_UTIL_ERROR_NONE;
  27
  28         image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
  29         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
  30         image_util_retvm_if((is_valid_colorspace(dest_colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dst_colorspace");
  31         image_util_retvm_if((is_valid_colorspace(src_colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid src_colorspace");
  32
  33         err = mm_util_convert_colorspace(src, width, height, TYPECAST_COLOR(src_colorspace), dest, TYPECAST_COLOR(dest_colorspace));
  34
  35         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
  36 }
  37
  38 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)
  39 {
  40         int err = MM_UTIL_ERROR_NONE;
  41         unsigned int res_w = 0;
  42         unsigned int res_h = 0;
  43         unsigned char *res_buffer = NULL;
  44         size_t res_buffer_size = 0;
  45
  46         image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
  47         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
  48         image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
  49         image_util_retvm_if((dest_width == NULL || dest_height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest_width or dest_height is null");
  50         image_util_retvm_if((*dest_width <= 0 || *dest_height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid dest_width or Invalid dest_height");
  51
  52         err = mm_util_resize_image(src, src_width, src_height, TYPECAST_COLOR(colorspace), *dest_width, dest_height, &res_buffer, &res_w, &res_h, &res_buffer_size);
  53         if (err == MM_UTIL_ERROR_NONE) {
  54                 memcpy(dest, res_buffer, res_buffer_size);
  55                 *dest_width = (int)res_w;
  56                 *dest_height = (int)res_h;
  57         }
  58
  59         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
  60 }
  61
  62 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)
  63 {
  64         int err = MM_UTIL_ERROR_NONE;
  65
  66         image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
  67         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
  68         image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
  69         image_util_retvm_if((dest_rotation < 0 || dest_rotation > IMAGE_UTIL_ROTATION_FLIP_VERT), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid rotation");
  70         image_util_retvm_if((dest_width == NULL || dest_height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest_width or dest_height is null");
  71
  72         unsigned int dest_w, dest_h;
  73         err = mm_util_rotate_image(src, src_width, src_height, TYPECAST_COLOR(colorspace), dest, &dest_w, &dest_h, dest_rotation);
  74         if (err == MM_UTIL_ERROR_NONE) {
  75                 *dest_width = (int)dest_w;
  76                 *dest_height = (int)dest_h;
  77         }
  78         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
  79 }
  80
  81 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)
  82 {
  83         int err = MM_UTIL_ERROR_NONE;
  84         unsigned int res_w = 0;
  85         unsigned int res_h = 0;
  86         unsigned char *res_buffer = NULL;
  87         size_t res_buffer_size = 0;
  88
  89         image_util_retvm_if((dest == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "dest is null");
  90         image_util_retvm_if((src == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "src is null");
  91         image_util_retvm_if((is_valid_colorspace(colorspace) == FALSE), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid colorspace");
  92         image_util_retvm_if((width == NULL || height == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "width or height is null");
  93         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");
  94
  95         err = mm_util_crop_image(src, src_width, src_height, TYPECAST_COLOR(colorspace), x, y, *width, *height, &res_buffer, &res_w, &res_h, &res_buffer_size);
  96         if (err == MM_UTIL_ERROR_NONE) {
  97                 memcpy(dest, res_buffer, res_buffer_size);
  98                 *width = (int)res_w;
  99                 *height = (int)res_h;
 100         }
 101
 102         return _image_error_capi(ERR_TYPE_TRANSFORM, err);
 103 }
 104
 105 int image_util_frame_create(void *decode_encode_h, image_util_frame_h *frame_h)
 106 {
 107         int ret = MM_UTIL_ERROR_NONE;
 108
 109         image_util_retvm_if((decode_encode_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 110         image_util_retvm_if((frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 111
 112         decode_encode_s *image = (decode_encode_s *)decode_encode_h;
 113         image_util_retvm_if((image->image_h == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "The image handle is wrong");
 114
 115         frame_s *frame = calloc(1, sizeof(frame_s));
 116         if (frame == NULL) {
 117                 image_util_error("Memory allocation is failed.");
 118                 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
 119         }
 120
 121         if (image->image_type == IMAGE_UTIL_GIF) {
 122                 mm_gif_file_h gif_data = (mm_gif_file_h)image->image_h;
 123                 mm_gif_image_h gif_frame = NULL;
 124
 125                 ret = mm_util_gif_image_create(gif_data, &gif_frame);
 126                 if (ret != MM_UTIL_ERROR_NONE) {
 127                         image_util_error("mm_util_gif_image_create is failed(%d).", ret);
 128                         IMAGE_UTIL_SAFE_FREE(frame);
 129                         return _image_error_capi(ERR_TYPE_ENCODE, ret);
 130                 }
 131                 frame->frame_h = gif_frame;
 132         } else {
 133                 image_util_error("The image type(%d) is not supported.", image->image_type);
 134                 IMAGE_UTIL_SAFE_FREE(frame);
 135                 return IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT;
 136         }
 137
 138         *frame_h = frame;
 139
 140         return IMAGE_UTIL_ERROR_NONE;
 141 }
 142
 143 int image_util_frame_set_resolution(image_util_frame_h frame_h, const int width, const int height)
 144 {
 145         int ret = MM_UTIL_ERROR_NONE;
 146
 147         image_util_retvm_if((frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 148         image_util_retvm_if((width <= 0) || (height <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Width or Height");
 149
 150         frame_s *frame = (frame_s *)frame_h;
 151
 152         ret = mm_util_gif_image_set_position(frame->frame_h, 0, 0, width, height);
 153         if (ret != MM_UTIL_ERROR_NONE) {
 154                 image_util_error("mm_util_gif_image_set_position is failed(%d).", ret);
 155                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 156         }
 157
 158         return IMAGE_UTIL_ERROR_NONE;
 159 }
 160
 161 int image_util_frame_set_gif_delay(image_util_frame_h frame_h, const int delay_time)
 162 {
 163         int ret = MM_UTIL_ERROR_NONE;
 164
 165         image_util_retvm_if((frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 166         image_util_retvm_if((delay_time <= 0), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Delay Time");
 167
 168         frame_s *frame = (frame_s *)frame_h;
 169
 170         ret = mm_util_gif_image_set_delay_time(frame->frame_h, delay_time);
 171         if (ret != MM_UTIL_ERROR_NONE) {
 172                 image_util_error("mm_util_gif_image_set_delay_time is failed(%d).", ret);
 173                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 174         }
 175
 176         return IMAGE_UTIL_ERROR_NONE;
 177 }
 178
 179 int image_util_frame_set_frame(image_util_frame_h frame_h, unsigned char *buffer)
 180 {
 181         int ret = MM_UTIL_ERROR_NONE;
 182
 183         image_util_retvm_if((frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 184         image_util_retvm_if((buffer == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Buffer");
 185
 186         frame_s *frame = (frame_s *)frame_h;
 187
 188         ret = mm_util_gif_image_set_image(frame->frame_h, buffer);
 189         if (ret != MM_UTIL_ERROR_NONE) {
 190                 image_util_error("mm_util_gif_image_set_image is failed(%d).", ret);
 191                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 192         }
 193
 194         return IMAGE_UTIL_ERROR_NONE;
 195 }
 196
 197 void image_util_frame_destroy(image_util_frame_h frame_h)
 198 {
 199         image_util_retm_if((frame_h == NULL), "Invalid Handle");
 200
 201         frame_s *frame = (frame_s *)frame_h;
 202         mm_util_gif_image_destory(frame->frame_h);
 203
 204         IMAGE_UTIL_SAFE_FREE(frame);
 205 }
 206
 207 int image_util_encode_add_frame(image_util_encode_h encode_h, image_util_frame_h frame_h)
 208 {
 209         int ret = MM_UTIL_ERROR_NONE;
 210
 211         image_util_retvm_if((encode_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 212         image_util_retvm_if((frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 213
 214         decode_encode_s *encode = (decode_encode_s *)encode_h;
 215         frame_s *frame = (frame_s *)frame_h;
 216         image_util_retvm_if((encode->image_h == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "The image handle is wrong");
 217         image_util_retvm_if((encode->image_type != IMAGE_UTIL_GIF), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "The image type(%d) is not supported.", encode->image_type);
 218         image_util_retvm_if((frame->frame_h == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "The frame handle is wrong");
 219
 220         mm_gif_file_h gif_data = (mm_gif_file_h)encode->image_h;
 221
 222         if (encode->current_buffer_count == 0) {
 223                 if (encode->path)
 224                         ret = mm_util_gif_encode_set_file(gif_data, encode->path);
 225                 else
 226                         ret = mm_util_gif_encode_set_mem(gif_data, encode->dst_buffer, &encode->gif_encode_size);
 227         }
 228         if (ret != MM_UTIL_ERROR_NONE) {
 229                 image_util_error("mm_util_gif_encode_add_image is failed(%d).", ret);
 230                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 231         }
 232
 233         ret = mm_util_gif_encode_add_image(gif_data, (mm_gif_image_h)frame->frame_h);
 234         if (ret != MM_UTIL_ERROR_NONE) {
 235                 image_util_error("mm_util_gif_encode_add_image is failed(%d).", ret);
 236                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 237         }
 238         encode->current_buffer_count++;
 239
 240         return IMAGE_UTIL_ERROR_NONE;
 241 }
 242
 243 int image_util_encode_save(image_util_encode_h encode_h, unsigned long long *size)
 244 {
 245         int ret = MM_UTIL_ERROR_NONE;
 246
 247         image_util_retvm_if((encode_h == NULL), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
 248
 249         decode_encode_s *encode = (decode_encode_s *)encode_h;
 250         image_util_retvm_if((encode->image_h == NULL), IMAGE_UTIL_ERROR_INVALID_OPERATION, "The image handle is wrong");
 251         image_util_retvm_if((encode->image_type != IMAGE_UTIL_GIF), IMAGE_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "The image type(%d) is not supported.", encode->image_type);
 252
 253         mm_gif_file_h gif_data = (mm_gif_file_h)encode->image_h;
 254
 255         ret = mm_util_gif_encode_save(gif_data);
 256         if (ret != MM_UTIL_ERROR_NONE) {
 257                 image_util_error("mm_util_gif_encode_save is failed(%d).", ret);
 258                 mm_util_gif_encode_destroy(gif_data);
 259                 return _image_error_capi(ERR_TYPE_ENCODE, ret);
 260         }
 261
 262         *size = (unsigned long long)encode->gif_encode_size;
 263         encode->current_buffer_count = 0;
 264
 265         return IMAGE_UTIL_ERROR_NONE;
 266 }