Modify check image type to decode image

Change-Id: I514c3523143614cc3e8f0790ef0c63be2cd9fdbe
Signed-off-by: Jiyong Min <jiyong.min@samsung.com>

diff --git a/packaging/capi-media-image-util.spec b/packaging/capi-media-image-util.spec
index 1b53bc701a8186daa0d5938de32f81f9e501c50d..6f81b136f3bb83e65a9efbc498aa28cfe633dee6 100755 (executable)
--- a/packaging/capi-media-image-util.spec
+++ b/packaging/capi-media-image-util.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-image-util
 Summary:    A Image Utility library in Tizen Native API
-Version:    0.1.26
+Version:    0.1.27
 Release:    2
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/image_util_decode.c b/src/image_util_decode.c
index 9ddb11c1e2fc646a915f3a302bdcefc49025f31d..ca3e22d1873b35adc44138ba780c8746b99b4190 100755 (executable)
--- a/src/image_util_decode.c
+++ b/src/image_util_decode.c
@@ -31,6 +31,80 @@ static int _convert_decode_scale_tbl[] = {
 };
 
 #define _NUM_OF_SCALE                  (sizeof(_convert_decode_scale_tbl)/sizeof(int))
+#define _NOT_SUPPORTED_IMAGE_TYPE (-1)
+
+static int _image_util_decode_read_header(const char *path, unsigned char **buffer)
+{
+#define IMG_HEADER_LENGTH 8
+
+       FILE *fp = NULL;
+       unsigned char *read_buffer = NULL;
+
+       image_util_retvm_if(!IMAGE_UTIL_STRING_VALID(path), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
+       image_util_retvm_if(buffer == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid buffer");
+
+       fp = fopen(path, "r");
+       if (fp == NULL) {
+               image_util_error("File open failed %s", path);
+               return IMAGE_UTIL_ERROR_NO_SUCH_FILE;
+       }
+
+       read_buffer = (void *)calloc(1, IMG_HEADER_LENGTH + 1);
+       if (read_buffer == NULL) {
+               image_util_error("Allocation fail");
+               fclose(fp);
+               fp = NULL;
+               return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
+       }
+
+       if (fread(read_buffer, 1, IMG_HEADER_LENGTH, fp) != IMG_HEADER_LENGTH) {
+               image_util_error("File read failed");
+               fclose(fp);
+               fp = NULL;
+               IMAGE_UTIL_SAFE_FREE(read_buffer);
+               return IMAGE_UTIL_ERROR_INVALID_OPERATION;
+       }
+
+       *buffer = read_buffer;
+
+       fclose(fp);
+       fp = NULL;
+
+       return IMAGE_UTIL_ERROR_NONE;
+}
+
+static int _image_util_decode_check_image_type(const unsigned char *image_buffer, image_util_type_e *image_type)
+{
+       static char _JPEG_HEADER[] = { 0xFF, 0xD8 };
+       static char _PNG_HEADER[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
+       static char _GIF_HEADER[] = { 'G', 'I', 'F' };
+       static char _BMP_HEADER[] = { 'B', 'M' };
+
+       static struct {
+               char *header;
+               int size;
+               image_util_type_e image_type;
+       } image_header[] = {
+               { _JPEG_HEADER, sizeof(_JPEG_HEADER), IMAGE_UTIL_JPEG },
+               { _PNG_HEADER, sizeof(_PNG_HEADER), IMAGE_UTIL_PNG },
+               { _GIF_HEADER, sizeof(_GIF_HEADER), IMAGE_UTIL_GIF },
+               { _BMP_HEADER, sizeof(_BMP_HEADER), IMAGE_UTIL_BMP }
+       ,};
+       unsigned int i = 0;
+
+       image_util_retvm_if((image_buffer == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid buffer");
+       image_util_retvm_if((image_type == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "Invalid type");
+
+       *image_type = _NOT_SUPPORTED_IMAGE_TYPE;        /* init */
+       for (i = 0; i < sizeof(image_header) / sizeof(image_header[0]); i++) {
+               if (strncmp((const char *)image_buffer, image_header[i].header, image_header[i].size) == 0) {
+                       *image_type = image_header[i].image_type;
+                       break;
+               }
+       }
+
+       return IMAGE_UTIL_ERROR_NONE;
+}
 
 static void _image_util_decode_destroy_image_handle(decode_encode_s * handle)
 {
@@ -129,36 +203,15 @@ int image_util_decode_create(image_util_decode_h * handle)
        _handle->path = NULL;
        _handle->image_h = 0;
        _handle->is_decode = TRUE;
-       _handle->image_type = -1;
+       _handle->image_type = _NOT_SUPPORTED_IMAGE_TYPE;
 
        *handle = (image_util_decode_h) _handle;
 
        return _convert_image_util_error_code(__func__, err);
 }
 
-static char _JPEG_HEADER[] = { 0xFF, 0xD8 };
-static char _PNG_HEADER[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
-static char _GIF_HEADER[] = { 'G', 'I', 'F' };
-static char _BMP_HEADER[] = { 'B', 'M' };
-
-static int _image_util_decode_create_image_handle(image_util_decode_h handle, const unsigned char *src_buffer)
+static int _image_util_decode_create_image_handle(image_util_decode_h handle)
 {
-       image_util_type_e image_type = -1;
-       static struct {
-               char *header;
-               int size;
-               image_util_type_e image_type;
-       } image_header[] = {
-               {
-               _JPEG_HEADER, sizeof(_JPEG_HEADER), IMAGE_UTIL_JPEG}
-               , {
-               _PNG_HEADER, sizeof(_PNG_HEADER), IMAGE_UTIL_PNG}
-               , {
-               _GIF_HEADER, sizeof(_GIF_HEADER), IMAGE_UTIL_GIF}
-               , {
-               _BMP_HEADER, sizeof(_BMP_HEADER), IMAGE_UTIL_BMP}
-       ,};
-       unsigned int i = 0;
        int err = MM_UTIL_ERROR_NONE;
        decode_encode_s *_handle = (decode_encode_s *) handle;
 
@@ -166,21 +219,8 @@ static int _image_util_decode_create_image_handle(image_util_decode_h handle, co
                image_util_error("Invalid Handle");
                return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
        }
-       if (src_buffer == NULL) {
-               image_util_error("Invalid input buffer");
-               return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
-       }
-
-       for (i = 0; i < sizeof(image_header) / sizeof(image_header[0]); i++) {
-               if (strncmp((const char *)src_buffer, image_header[i].header, image_header[i].size) == 0) {
-                       image_type = image_header[i].image_type;
-                       break;
-               }
-       }
 
-       _handle->image_type = image_type;
-
-       switch (image_type) {
+       switch (_handle->image_type) {
        case IMAGE_UTIL_JPEG:
                err = _image_util_decode_create_jpeg_handle(_handle);
                break;
@@ -210,52 +250,35 @@ int image_util_decode_set_input_path(image_util_decode_h handle, const char *pat
 {
        int err = IMAGE_UTIL_ERROR_NONE;
        decode_encode_s *_handle = (decode_encode_s *) handle;
-       FILE *fp = NULL;
-       unsigned char *src_buffer = NULL;
+       unsigned char *image_header = NULL;
 
-       if (_handle == NULL || _handle->is_decode == FALSE) {
-               image_util_error("Invalid Handle");
-               return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
-       }
-       image_util_retvm_if((path == NULL || strlen(path) == 0), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
+       image_util_retvm_if(((_handle == NULL) || (_handle->is_decode == FALSE)), IMAGE_UTIL_ERROR_INVALID_PARAMETER, "Invalid Handle");
+       image_util_retvm_if(!IMAGE_UTIL_STRING_VALID(path), IMAGE_UTIL_ERROR_NO_SUCH_FILE, "Invalid path");
 
        if (_handle->src_buffer)
                _handle->src_buffer = NULL;
 
-       fp = fopen(path, "r");
-       if (fp == NULL) {
-               image_util_error("File open failed %s", path);
-               return IMAGE_UTIL_ERROR_NO_SUCH_FILE;
-       }
-       src_buffer = (void *)malloc(sizeof(_PNG_HEADER));
-       if (src_buffer == NULL) {
-               image_util_error("malloc fail");
-               fclose(fp);
-               fp = NULL;
-               return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
+       err = _image_util_decode_read_header(path, &image_header);
+       if (err != IMAGE_UTIL_ERROR_NONE) {
+               image_util_error("_image_util_decode_read_header failed");
+               return err;
        }
 
-       if (!fread(src_buffer, 1, sizeof(_PNG_HEADER), fp)) {
-               image_util_error("File read failed");
-               fclose(fp);
-               fp = NULL;
-               IMAGE_UTIL_SAFE_FREE(src_buffer);
-               return IMAGE_UTIL_ERROR_INVALID_OPERATION;
+       err = _image_util_decode_check_image_type(image_header, &_handle->image_type);
+       if (err != IMAGE_UTIL_ERROR_NONE) {
+               image_util_error("_image_util_decode_check_image_type failed");
+               IMAGE_UTIL_SAFE_FREE(image_header);
+               return err;
        }
 
-       err = _image_util_decode_create_image_handle(_handle, src_buffer);
+       IMAGE_UTIL_SAFE_FREE(image_header);
+
+       err = _image_util_decode_create_image_handle(_handle);
        if (err != IMAGE_UTIL_ERROR_NONE) {
                image_util_error("_image_util_decode_create_image_handle failed");
-               fclose(fp);
-               fp = NULL;
-               IMAGE_UTIL_SAFE_FREE(src_buffer);
                return err;
        }
 
-       fclose(fp);
-       fp = NULL;
-       IMAGE_UTIL_SAFE_FREE(src_buffer);
-
        _handle->path = g_strndup(path, strlen(path));
 
        return err;
@@ -277,7 +300,13 @@ int image_util_decode_set_input_buffer(image_util_decode_h handle, const unsigne
 
        IMAGE_UTIL_SAFE_FREE(_handle->path);
 
-       err = _image_util_decode_create_image_handle(_handle, src_buffer);
+       err = _image_util_decode_check_image_type(src_buffer, &_handle->image_type);
+       if (err != IMAGE_UTIL_ERROR_NONE) {
+               image_util_error("_image_util_decode_check_image_type failed");
+               return err;
+       }
+
+       err = _image_util_decode_create_image_handle(_handle);
        if (err != IMAGE_UTIL_ERROR_NONE) {
                image_util_error("_image_util_decode_create_image_handle failed");
                return err;