[UTC][capi-media-image-util][Non-ACR][Modify functions to get buffer on precondition...

  - code simplify and add debug message on precondition
  - minor change. use meaningful function name

Change-Id: I3e0bd58ef604a5f753e9081d7396e14029c57f4a

diff --git a/src/utc/image-util/utc-image-util-agif-encode.c b/src/utc/image-util/utc-image-util-agif-encode.c
index 4cd9a7cb2ab05bc484bb49d629467fb938c0e4fd..a429e215aea3c058a3145261a76035c0bf3d35c9 100644 (file)
--- a/src/utc/image-util/utc-image-util-agif-encode.c
+++ b/src/utc/image-util/utc-image-util-agif-encode.c
@@ -63,7 +63,7 @@ void utc_image_util_agif_encode_startup(void)
        if (!g_utc_path_origin || !g_utc_path_agif)
                FPRINTF("[%d:%s] Get UTC Path error! \\n", __LINE__, __FUNCTION__);
 
-       ret = _utc_decode_simple(g_utc_path_origin, &g_utc_img_origin);
+       ret = _utc_decode_from_file(g_utc_path_origin, &g_utc_img_origin);
        if (ret != IMAGE_UTIL_ERROR_NONE)
                FPRINTF("[%d:%s] Startup error! \\n", __LINE__, __FUNCTION__);
 }

diff --git a/src/utc/image-util/utc-image-util-common.c b/src/utc/image-util/utc-image-util-common.c
index 480a1adbf5b958aea766d174e8bf9f0078856e8b..e2ee7072ae3f8ca66ac1b8a1ad5927198fd5e557 100644 (file)
--- a/src/utc/image-util/utc-image-util-common.c
+++ b/src/utc/image-util/utc-image-util-common.c
@@ -43,7 +43,7 @@ char *_utc_get_test_path(const char *base_dir, const char *filename)
        return g_strdup_printf("%s/res/%s", base_dir, filename);
 }
 
-int _utc_decode_simple(const char *path, image_util_image_h *decoded_image)
+int _utc_decode_from_file(const char *path, image_util_image_h *decoded_image)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_decode_h decoder = NULL;
@@ -70,6 +70,26 @@ int _utc_decode_simple(const char *path, image_util_image_h *decoded_image)
        return ret;
 }
 
+int _utc_encode_to_buffer(image_util_type_e type, image_util_image_h decoded_image, unsigned char **buffer, size_t *buffer_size)
+{
+       int ret = IMAGE_UTIL_ERROR_NONE;
+       image_util_encode_h encoder = NULL;
+
+       ret = image_util_encode_create(type, &encoder);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] image_util_encode_create failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               return ret;
+       }
+
+       ret = image_util_encode_run_to_buffer(encoder, decoded_image, buffer, buffer_size);
+       if (ret != IMAGE_UTIL_ERROR_NONE)
+               FPRINTF("[%d:%s] image_util_encode_run_to_buffer failed! %d \\n", __LINE__, __FUNCTION__, ret);
+
+       image_util_encode_destroy(encoder);
+
+       return ret;
+}
+
 /**
 * @}
 */

diff --git a/src/utc/image-util/utc-image-util-common.h b/src/utc/image-util/utc-image-util-common.h
index d0792ecdcbf1f8faad3239e820a928c8322e9d10..2ec35900f39812479152f439c5f64735cbfed501 100644 (file)
--- a/src/utc/image-util/utc-image-util-common.h
+++ b/src/utc/image-util/utc-image-util-common.h
@@ -48,6 +48,7 @@
     } while (0)
 
 char *_utc_get_test_path(const char *base_dir, const char *filename);
-int _utc_decode_simple(const char *path, image_util_image_h *decoded_image);
+int _utc_decode_from_file(const char *path, image_util_image_h *decoded_image);
+int _utc_encode_to_buffer(image_util_type_e type, image_util_image_h decoded_image, unsigned char **buffer, size_t *buffer_size);
 
 #endif /* _UTC_MEDIA_CONTROLLER_COMMON_H_ */

diff --git a/src/utc/image-util/utc-image-util-decode-encode.c b/src/utc/image-util/utc-image-util-decode-encode.c
index bff149bd5aa908f41f1a40fd50f042a301068b4e..bf0c3d46ec4a636ad18e41f83001986d67471bd5 100755 (executable)
--- a/src/utc/image-util/utc-image-util-decode-encode.c
+++ b/src/utc/image-util/utc-image-util-decode-encode.c
@@ -29,8 +29,6 @@
 
 static image_util_decode_h jpeg_decode_h = NULL;
 static image_util_encode_h jpeg_encode_h = NULL;
-static image_util_decode_h jpeg_decoded_h = NULL;
-static image_util_encode_h jpeg_encoded_h = NULL;
 static char *jpeg_file1 = "sample.jpg";
 static char *jpeg_file2 = "test_output.jpg";
 static char *jpeg_path1 = NULL;
@@ -49,8 +47,6 @@ static struct {
 
 static image_util_decode_h png_decode_h = NULL;
 static image_util_encode_h png_encode_h = NULL;
-static image_util_decode_h png_decoded_h = NULL;
-static image_util_encode_h png_encoded_h = NULL;
 static char *png_file1 = "sample.png";
 static char *png_file2 = "test_output.png";
 static char *png_path1 = NULL;
@@ -69,8 +65,6 @@ static struct {
 
 static image_util_decode_h gif_decode_h = NULL;
 static image_util_encode_h gif_encode_h = NULL;
-static image_util_decode_h gif_decoded_h = NULL;
-static image_util_encode_h gif_encoded_h = NULL;
 static char *gif_file1 = "sample.gif";
 static char *gif_file2 = "test_output.gif";
 static char *gif_path1 = NULL;
@@ -89,8 +83,6 @@ static struct {
 
 static image_util_decode_h bmp_decode_h = NULL;
 static image_util_encode_h bmp_encode_h = NULL;
-static image_util_decode_h bmp_decoded_h = NULL;
-static image_util_encode_h bmp_encoded_h = NULL;
 
 static char *bmp_file1 = "sample.bmp";
 static char *bmp_file2 = "test_output.bmp";
@@ -214,138 +206,114 @@ static void utc_encode_to_buffer_completed_cb(image_util_error_e error, unsigned
        _signal();
 }
 
-static int fill_jpeg_decoded_encoded_buffer(void)
+static int __fill_jpeg_decoded_encoded_buffer(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_image_h decoded_image = NULL;
 
-       ret = image_util_decode_create(&jpeg_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_set_input_path(jpeg_decoded_h, jpeg_path1);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_run2(jpeg_decoded_h, &decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_destroy(jpeg_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_get_image(decoded_image, &jpeg_decoded_image.width, &jpeg_decoded_image.height, NULL, &jpeg_decoded_image.buffer, &jpeg_decoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_destroy_image(decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = _utc_decode_from_file(jpeg_path1, &decoded_image);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] _utc_decode_from_file failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               return ret;
+       }
 
-       ret = image_util_encode_create(IMAGE_UTIL_JPEG, &jpeg_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_resolution(jpeg_encoded_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_input_buffer(jpeg_encoded_h, jpeg_decoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_output_buffer(jpeg_encoded_h, &jpeg_encoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_run(jpeg_encoded_h, &jpeg_encoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_destroy(jpeg_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = image_util_get_image(decoded_image, &jpeg_decoded_image.width, &jpeg_decoded_image.height, NULL,
+                                                               &jpeg_decoded_image.buffer, &jpeg_decoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] image_util_get_image failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               image_util_destroy_image(decoded_image);
+               return ret;
+       }
+
+       ret = _utc_encode_to_buffer(IMAGE_UTIL_JPEG, decoded_image, &jpeg_encoded_image.buffer, &jpeg_encoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE)
+               FPRINTF("[%d:%s] _utc_encode_to_buffer failed! %d \\n", __LINE__, __FUNCTION__, ret);
+
+       image_util_destroy_image(decoded_image);
 
        return ret;
 }
 
-static int fill_png_decoded_encoded_buffer(void)
+static int __fill_png_decoded_encoded_buffer(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_image_h decoded_image = NULL;
 
-       ret = image_util_decode_create(&png_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_set_input_path(png_decoded_h, png_path1);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_run2(png_decoded_h, &decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_destroy(png_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_get_image(decoded_image, &png_decoded_image.width, &png_decoded_image.height, NULL, &png_decoded_image.buffer, &png_decoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_destroy_image(decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = _utc_decode_from_file(png_path1, &decoded_image);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] _utc_decode_from_file failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               return ret;
+       }
 
-       ret = image_util_encode_create(IMAGE_UTIL_PNG, &png_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_resolution(png_encoded_h, png_decoded_image.width, png_decoded_image.height);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_input_buffer(png_encoded_h, png_decoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_output_buffer(png_encoded_h, &png_encoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_run(png_encoded_h, &png_encoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_destroy(png_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = image_util_get_image(decoded_image, &png_decoded_image.width, &png_decoded_image.height, NULL,
+                                                               &png_decoded_image.buffer, &png_decoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] image_util_get_image failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               image_util_destroy_image(decoded_image);
+               return ret;
+       }
+
+       ret = _utc_encode_to_buffer(IMAGE_UTIL_PNG, decoded_image, &png_encoded_image.buffer, &png_encoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE)
+               FPRINTF("[%d:%s] _utc_encode_to_buffer failed! %d \\n", __LINE__, __FUNCTION__, ret);
+
+       image_util_destroy_image(decoded_image);
 
        return ret;
 }
 
-static int fill_gif_decoded_encoded_buffer(void)
+static int __fill_gif_decoded_encoded_buffer(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_image_h decoded_image = NULL;
 
-       ret = image_util_decode_create(&gif_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_set_input_path(gif_decoded_h, gif_path1);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_run2(gif_decoded_h, &decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_destroy(gif_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_get_image(decoded_image, &gif_decoded_image.width, &gif_decoded_image.height, NULL, &gif_decoded_image.buffer, &gif_decoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_destroy_image(decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = _utc_decode_from_file(gif_path1, &decoded_image);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] _utc_decode_from_file failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               return ret;
+       }
 
-       ret = image_util_encode_create(IMAGE_UTIL_GIF, &gif_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_resolution(gif_encoded_h, gif_decoded_image.width, gif_decoded_image.height);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_input_buffer(gif_encoded_h, gif_decoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_output_buffer(gif_encoded_h, &gif_encoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_run(gif_encoded_h, &gif_encoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_destroy(gif_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = image_util_get_image(decoded_image, &gif_decoded_image.width, &gif_decoded_image.height, NULL,
+                                                               &gif_decoded_image.buffer, &gif_decoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] image_util_get_image failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               image_util_destroy_image(decoded_image);
+               return ret;
+       }
+
+       ret = _utc_encode_to_buffer(IMAGE_UTIL_GIF, decoded_image, &gif_encoded_image.buffer, &gif_encoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE)
+               FPRINTF("[%d:%s] _utc_encode_to_buffer failed! %d \\n", __LINE__, __FUNCTION__, ret);
+
+       image_util_destroy_image(decoded_image);
 
        return ret;
 }
 
-static int fill_bmp_decoded_encoded_buffer(void)
+static int __fill_bmp_decoded_encoded_buffer(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_image_h decoded_image = NULL;
 
-       ret = image_util_decode_create(&bmp_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_set_input_path(bmp_decoded_h, bmp_path1);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_run2(bmp_decoded_h, &decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_decode_destroy(bmp_decoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_get_image(decoded_image, &bmp_decoded_image.width, &bmp_decoded_image.height, NULL, &bmp_decoded_image.buffer, &bmp_decoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_destroy_image(decoded_image);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = _utc_decode_from_file(bmp_path1, &decoded_image);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] _utc_decode_from_file failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               return ret;
+       }
 
-       ret = image_util_encode_create(IMAGE_UTIL_GIF, &bmp_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_resolution(bmp_encoded_h, bmp_decoded_image.width, bmp_decoded_image.height);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_input_buffer(bmp_encoded_h, gif_decoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_set_output_buffer(bmp_encoded_h, &bmp_encoded_image.buffer);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_run(bmp_encoded_h, &bmp_encoded_image.size);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
-       ret = image_util_encode_destroy(bmp_encoded_h);
-       assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
+       ret = image_util_get_image(decoded_image, &bmp_decoded_image.width, &bmp_decoded_image.height, NULL,
+                                                               &bmp_decoded_image.buffer, &bmp_decoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE) {
+               FPRINTF("[%d:%s] image_util_get_image failed! %d \\n", __LINE__, __FUNCTION__, ret);
+               image_util_destroy_image(decoded_image);
+               return ret;
+       }
+
+       ret = _utc_encode_to_buffer(IMAGE_UTIL_BMP, decoded_image, &bmp_encoded_image.buffer, &bmp_encoded_image.size);
+       if (ret != IMAGE_UTIL_ERROR_NONE)
+               FPRINTF("[%d:%s] _utc_encode_to_buffer failed! %d \\n", __LINE__, __FUNCTION__, ret);
+
+       image_util_destroy_image(decoded_image);
 
        return ret;
 }
@@ -631,7 +599,7 @@ int utc_image_util_decode_set_input_buffer_n1(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(NULL, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -648,7 +616,7 @@ int utc_image_util_decode_set_input_buffer_n2(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_encode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -665,7 +633,7 @@ int utc_image_util_decode_set_input_buffer_n3(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, NULL, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -682,7 +650,7 @@ int utc_image_util_decode_set_input_buffer_n4(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, 0);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -699,7 +667,7 @@ int utc_image_util_decode_set_input_buffer_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1056,7 +1024,7 @@ int utc_image_util_decode_run_n5(void)
        unsigned long image_width = 0, image_height = 0;
        unsigned long long image_size = 0;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1125,7 +1093,7 @@ int utc_image_util_decode_run_p2(void)
        unsigned long image_width = 0, image_height = 0;
        unsigned long long image_size = 0;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(jpeg_decode_h, jpeg_encoded_image.buffer, jpeg_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1135,7 +1103,7 @@ int utc_image_util_decode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1145,7 +1113,7 @@ int utc_image_util_decode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(gif_decode_h, gif_encoded_image.buffer, gif_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1155,7 +1123,7 @@ int utc_image_util_decode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(bmp_decode_h, bmp_encoded_image.buffer, bmp_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1240,7 +1208,7 @@ int utc_image_util_decode_run2_p2(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        image_util_image_h decoded_image = NULL;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(jpeg_decode_h, jpeg_encoded_image.buffer, jpeg_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1249,7 +1217,7 @@ int utc_image_util_decode_run2_p2(void)
        ret = image_util_destroy_image(decoded_image);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1258,7 +1226,7 @@ int utc_image_util_decode_run2_p2(void)
        ret = image_util_destroy_image(decoded_image);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(gif_decode_h, gif_encoded_image.buffer, gif_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1267,7 +1235,7 @@ int utc_image_util_decode_run2_p2(void)
        ret = image_util_destroy_image(decoded_image);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(bmp_decode_h, bmp_encoded_image.buffer, bmp_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1354,7 +1322,7 @@ int utc_image_util_decode_run_async_n5(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1447,7 +1415,7 @@ int utc_image_util_decode_run_async_p2(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned char *data = NULL;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(jpeg_decode_h, jpeg_encoded_image.buffer, jpeg_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1459,7 +1427,7 @@ int utc_image_util_decode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1471,7 +1439,7 @@ int utc_image_util_decode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(gif_decode_h, gif_encoded_image.buffer, gif_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1483,7 +1451,7 @@ int utc_image_util_decode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(bmp_decode_h, bmp_encoded_image.buffer, bmp_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1572,7 +1540,7 @@ int utc_image_util_decode_run_async2_p2(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
 
        callback_error = -1;
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(jpeg_decode_h, jpeg_encoded_image.buffer, jpeg_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1582,7 +1550,7 @@ int utc_image_util_decode_run_async2_p2(void)
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
        callback_error = -1;
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(png_decode_h, png_encoded_image.buffer, png_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1592,7 +1560,7 @@ int utc_image_util_decode_run_async2_p2(void)
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
        callback_error = -1;
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(gif_decode_h, gif_encoded_image.buffer, gif_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1602,7 +1570,7 @@ int utc_image_util_decode_run_async2_p2(void)
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
        callback_error = -1;
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_decode_set_input_buffer(bmp_decode_h, bmp_encoded_image.buffer, bmp_encoded_image.size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -1913,7 +1881,7 @@ int utc_image_util_encode_set_resolution_n4(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_set_resolution(gif_encode_h, 320, 240);
@@ -2291,7 +2259,7 @@ int utc_image_util_encode_set_input_buffer_n1(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(NULL, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -2308,7 +2276,7 @@ int utc_image_util_encode_set_input_buffer_n2(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_decode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_INVALID_PARAMETER);
@@ -2340,7 +2308,7 @@ int utc_image_util_encode_set_input_buffer_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_encode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2544,7 +2512,7 @@ int utc_image_util_encode_run_n4(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long image_size = 0;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_encode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2601,7 +2569,7 @@ int utc_image_util_encode_run_n7(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long image_size = 0;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_encode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2623,7 +2591,7 @@ int utc_image_util_encode_run_n8(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long image_size = 0;
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
@@ -2650,7 +2618,7 @@ int utc_image_util_encode_run_p1(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long image_size = 0;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(jpeg_encode_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2661,7 +2629,7 @@ int utc_image_util_encode_run_p1(void)
        ret = image_util_encode_run(jpeg_encode_h, &image_size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2672,7 +2640,7 @@ int utc_image_util_encode_run_p1(void)
        ret = image_util_encode_run(png_encode_h, &image_size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2683,7 +2651,7 @@ int utc_image_util_encode_run_p1(void)
        ret = image_util_encode_run(gif_encode_h, &image_size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(bmp_encode_h, bmp_decoded_image.width, bmp_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2708,7 +2676,7 @@ int utc_image_util_encode_run_p2(void)
        unsigned char *data = NULL;
        unsigned long long image_size = 0;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(jpeg_encode_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2720,7 +2688,7 @@ int utc_image_util_encode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2732,7 +2700,7 @@ int utc_image_util_encode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2744,7 +2712,7 @@ int utc_image_util_encode_run_p2(void)
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        IMAGEUTIL_SAFE_FREE(data);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(bmp_encode_h, bmp_decoded_image.width, bmp_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2769,7 +2737,7 @@ int utc_image_util_encode_run_p3(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long size = 0;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(jpeg_encode_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2780,7 +2748,7 @@ int utc_image_util_encode_run_p3(void)
        ret = image_util_encode_run(jpeg_encode_h, &size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2791,7 +2759,7 @@ int utc_image_util_encode_run_p3(void)
        ret = image_util_encode_run(png_encode_h, &size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2802,7 +2770,7 @@ int utc_image_util_encode_run_p3(void)
        ret = image_util_encode_run(gif_encode_h, &size);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(bmp_encode_h, bmp_decoded_image.width, bmp_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2826,7 +2794,7 @@ int utc_image_util_encode_run_p4(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned long long size = 0;
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2902,7 +2870,7 @@ int utc_image_util_encode_run_async_n4(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_encode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2956,7 +2924,7 @@ int utc_image_util_encode_run_async_n7(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_input_buffer(png_encode_h, png_decoded_image.buffer);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -2977,7 +2945,7 @@ int utc_image_util_encode_run_async_n8(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3000,7 +2968,7 @@ int utc_image_util_encode_run_async_n9(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3027,7 +2995,7 @@ int utc_image_util_encode_run_async_p1(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(jpeg_encode_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3040,7 +3008,7 @@ int utc_image_util_encode_run_async_p1(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3053,7 +3021,7 @@ int utc_image_util_encode_run_async_p1(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3066,7 +3034,7 @@ int utc_image_util_encode_run_async_p1(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(bmp_encode_h, bmp_decoded_image.width, bmp_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3092,7 +3060,7 @@ int utc_image_util_encode_run_async_p2(void)
        int ret = IMAGE_UTIL_ERROR_NONE;
        unsigned char *data = NULL;
 
-       ret = fill_jpeg_decoded_encoded_buffer();
+       ret = __fill_jpeg_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(jpeg_encode_h, jpeg_decoded_image.width, jpeg_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3106,7 +3074,7 @@ int utc_image_util_encode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_png_decoded_encoded_buffer();
+       ret = __fill_png_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(png_encode_h, png_decoded_image.width, png_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3120,7 +3088,7 @@ int utc_image_util_encode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_gif_decoded_encoded_buffer();
+       ret = __fill_gif_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(gif_encode_h, gif_decoded_image.width, gif_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3134,7 +3102,7 @@ int utc_image_util_encode_run_async_p2(void)
        IMAGEUTIL_SAFE_FREE(data);
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = fill_bmp_decoded_encoded_buffer();
+       ret = __fill_bmp_decoded_encoded_buffer();
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
        ret = image_util_encode_set_resolution(bmp_encode_h, bmp_decoded_image.width, bmp_decoded_image.height);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
@@ -3160,25 +3128,25 @@ int utc_image_util_encode_run_to_file_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_file(jpeg_encode_h, g_img_dec_jpeg, jpeg_path2);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(png_path1, &g_img_dec_png);
+       ret = _utc_decode_from_file(png_path1, &g_img_dec_png);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_file(png_encode_h, g_img_dec_png, png_path2);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(gif_path1, &g_img_dec_gif);
+       ret = _utc_decode_from_file(gif_path1, &g_img_dec_gif);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_file(gif_encode_h, g_img_dec_gif, gif_path2);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(bmp_path1, &g_img_dec_bmp);
+       ret = _utc_decode_from_file(bmp_path1, &g_img_dec_bmp);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_file(bmp_encode_h, g_img_dec_bmp, bmp_path2);
@@ -3196,7 +3164,7 @@ int utc_image_util_encode_run_to_file_n(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_file(NULL, g_img_dec_jpeg, jpeg_path2);
@@ -3220,7 +3188,7 @@ int utc_image_util_encode_run_to_buffer_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_buffer(jpeg_encode_h, g_img_dec_jpeg, &g_buf_enc_jpeg.buffer, &g_buf_enc_jpeg.buffer_size);
@@ -3228,7 +3196,7 @@ int utc_image_util_encode_run_to_buffer_p(void)
        assert_neq(g_buf_enc_jpeg.buffer, NULL);
        assert_gt(g_buf_enc_jpeg.buffer_size, 0);
 
-       ret = _utc_decode_simple(png_path1, &g_img_dec_png);
+       ret = _utc_decode_from_file(png_path1, &g_img_dec_png);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_buffer(png_encode_h, g_img_dec_png, &g_buf_enc_png.buffer, &g_buf_enc_png.buffer_size);
@@ -3236,7 +3204,7 @@ int utc_image_util_encode_run_to_buffer_p(void)
        assert_neq(g_buf_enc_png.buffer, NULL);
        assert_gt(g_buf_enc_png.buffer_size, 0);
 
-       ret = _utc_decode_simple(gif_path1, &g_img_dec_gif);
+       ret = _utc_decode_from_file(gif_path1, &g_img_dec_gif);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_buffer(gif_encode_h, g_img_dec_gif, &g_buf_enc_gif.buffer, &g_buf_enc_gif.buffer_size);
@@ -3244,7 +3212,7 @@ int utc_image_util_encode_run_to_buffer_p(void)
        assert_neq(g_buf_enc_gif.buffer, NULL);
        assert_gt(g_buf_enc_gif.buffer_size, 0);
 
-       ret = _utc_decode_simple(bmp_path1, &g_img_dec_bmp);
+       ret = _utc_decode_from_file(bmp_path1, &g_img_dec_bmp);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_buffer(bmp_encode_h, g_img_dec_bmp, &g_buf_enc_bmp.buffer, &g_buf_enc_bmp.buffer_size);
@@ -3264,7 +3232,7 @@ int utc_image_util_encode_run_to_buffer_n(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_to_buffer(NULL, g_img_dec_jpeg, &g_buf_enc_jpeg.buffer, &g_buf_enc_jpeg.buffer_size);
@@ -3291,7 +3259,7 @@ int utc_image_util_encode_run_async_to_file_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_file(jpeg_encode_h, g_img_dec_jpeg, jpeg_path2, utc_encode_to_file_completed_cb, NULL);
@@ -3299,7 +3267,7 @@ int utc_image_util_encode_run_async_to_file_p(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(png_path1, &g_img_dec_png);
+       ret = _utc_decode_from_file(png_path1, &g_img_dec_png);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_file(png_encode_h, g_img_dec_png, png_path2, utc_encode_to_file_completed_cb, NULL);
@@ -3307,7 +3275,7 @@ int utc_image_util_encode_run_async_to_file_p(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(gif_path1, &g_img_dec_gif);
+       ret = _utc_decode_from_file(gif_path1, &g_img_dec_gif);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_file(gif_encode_h, g_img_dec_gif, gif_path2, utc_encode_to_file_completed_cb, NULL);
@@ -3315,7 +3283,7 @@ int utc_image_util_encode_run_async_to_file_p(void)
        wait_for_async();
        assert_eq(callback_error, IMAGE_UTIL_ERROR_NONE);
 
-       ret = _utc_decode_simple(bmp_path1, &g_img_dec_bmp);
+       ret = _utc_decode_from_file(bmp_path1, &g_img_dec_bmp);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_file(bmp_encode_h, g_img_dec_bmp, bmp_path2, utc_encode_to_file_completed_cb, NULL);
@@ -3335,7 +3303,7 @@ int utc_image_util_encode_run_async_to_file_n(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_file(NULL, g_img_dec_jpeg, jpeg_path2, utc_encode_to_file_completed_cb, NULL);
@@ -3362,7 +3330,7 @@ int utc_image_util_encode_run_async_to_buffer_p(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_buffer(jpeg_encode_h, g_img_dec_jpeg, utc_encode_to_buffer_completed_cb, &g_buf_enc_jpeg);
@@ -3372,7 +3340,7 @@ int utc_image_util_encode_run_async_to_buffer_p(void)
        assert_neq(g_buf_enc_jpeg.buffer, NULL);
        assert_gt(g_buf_enc_jpeg.buffer_size, 0);
 
-       ret = _utc_decode_simple(png_path1, &g_img_dec_png);
+       ret = _utc_decode_from_file(png_path1, &g_img_dec_png);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_buffer(png_encode_h, g_img_dec_png, utc_encode_to_buffer_completed_cb, &g_buf_enc_png);
@@ -3382,7 +3350,7 @@ int utc_image_util_encode_run_async_to_buffer_p(void)
        assert_neq(g_buf_enc_png.buffer, NULL);
        assert_gt(g_buf_enc_png.buffer_size, 0);
 
-       ret = _utc_decode_simple(gif_path1, &g_img_dec_gif);
+       ret = _utc_decode_from_file(gif_path1, &g_img_dec_gif);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_buffer(gif_encode_h, g_img_dec_gif, utc_encode_to_buffer_completed_cb, &g_buf_enc_gif);
@@ -3392,7 +3360,7 @@ int utc_image_util_encode_run_async_to_buffer_p(void)
        assert_neq(g_buf_enc_gif.buffer, NULL);
        assert_gt(g_buf_enc_gif.buffer_size, 0);
 
-       ret = _utc_decode_simple(bmp_path1, &g_img_dec_bmp);
+       ret = _utc_decode_from_file(bmp_path1, &g_img_dec_bmp);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_buffer(bmp_encode_h, g_img_dec_bmp, utc_encode_to_buffer_completed_cb, &g_buf_enc_bmp);
@@ -3414,7 +3382,7 @@ int utc_image_util_encode_run_async_to_buffer_n(void)
 {
        int ret = IMAGE_UTIL_ERROR_NONE;
 
-       ret = _utc_decode_simple(jpeg_path1, &g_img_dec_jpeg);
+       ret = _utc_decode_from_file(jpeg_path1, &g_img_dec_jpeg);
        assert_eq(ret, IMAGE_UTIL_ERROR_NONE);
 
        ret = image_util_encode_run_async_to_buffer(NULL, g_img_dec_jpeg, utc_encode_to_buffer_completed_cb, NULL);