From 3b32e13796bd8efc159935ef50a13b141f5bb3be Mon Sep 17 00:00:00 2001 From: hj kim Date: Mon, 11 Mar 2019 18:00:39 +0900 Subject: [PATCH] Modify parameter in decoding APIs from mm_image_info_s to mm_util_image_h Change-Id: Ie9c0cbcd5cf979ccd99a34f75fb1a487d62de9ff --- bmp/include/mm_util_bmp.h | 4 +- bmp/mm_util_bmp.c | 64 ++--- bmp/test/CMakeLists.txt | 2 +- bmp/test/mm_util_bmp_testsuite.c | 47 +++- bmp/unittest/libmm_bmp_unittest.cpp | 41 ++- gif/CMakeLists.txt | 4 +- gif/include/mm_util_gif.h | 4 +- gif/mm_util_gif.c | 52 ++-- gif/test/CMakeLists.txt | 4 +- gif/test/mm_util_gif_testsuite.c | 429 ++++++++++++++++++++++++-------- gif/unittest/libmm_gif_unittest.cpp | 43 ++-- imgcv/test/CMakeLists.txt | 2 +- imgcv/test/mm_util_imgcv_testsuite.c | 22 +- imgcv/unittest/libmm_imgcv_unittest.cpp | 17 +- imgp/unittest/libmm_imgp_unittest.cpp | 73 ++++-- jpeg/include/mm_util_jpeg.h | 4 +- jpeg/mm_util_jpeg.c | 115 ++++----- jpeg/test/CMakeLists.txt | 2 +- jpeg/test/mm_util_jpeg_testsuite.c | 61 +++-- jpeg/unittest/libmm_jpeg_unittest.cpp | 109 +++----- png/include/mm_util_png.h | 4 +- png/mm_util_png.c | 67 ++--- png/test/CMakeLists.txt | 2 +- png/test/mm_util_png_testsuite.c | 49 +++- png/unittest/libmm_png_unittest.cpp | 41 ++- 25 files changed, 747 insertions(+), 515 deletions(-) mode change 100755 => 100644 bmp/test/CMakeLists.txt mode change 100644 => 100755 gif/mm_util_gif.c mode change 100755 => 100644 gif/test/CMakeLists.txt mode change 100755 => 100644 imgcv/test/CMakeLists.txt mode change 100755 => 100644 imgcv/test/mm_util_imgcv_testsuite.c mode change 100755 => 100644 jpeg/test/CMakeLists.txt mode change 100755 => 100644 png/test/CMakeLists.txt diff --git a/bmp/include/mm_util_bmp.h b/bmp/include/mm_util_bmp.h index 398a462..31cb4c8 100755 --- a/bmp/include/mm_util_bmp.h +++ b/bmp/include/mm_util_bmp.h @@ -27,8 +27,8 @@ extern "C" { #endif #include "mm_util_type.h" -int mm_util_decode_from_bmp_file(const char *filename, mm_image_info_s * decoded); -int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_image_info_s * decoded); +int mm_util_decode_from_bmp_file(const char *file_path, mm_util_image_h *decoded); +int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); int mm_util_encode_bmp_to_file(mm_image_info_s * decoded, const char *filename); int mm_util_encode_bmp_to_memory(mm_image_info_s *decoded, void **buffer, size_t *size); diff --git a/bmp/mm_util_bmp.c b/bmp/mm_util_bmp.c index 699b493..2d12d7e 100755 --- a/bmp/mm_util_bmp.c +++ b/bmp/mm_util_bmp.c @@ -116,7 +116,7 @@ static void __print_error(const char *context, bmp_result code) } /* decodes bmp image to color image */ -static int _read_bmp(const char *filename, void *memory, size_t src_size, mm_image_info_s *decoded) +static int __read_bmp(const char *file_path, void *memory, size_t src_size, mm_util_image_h *decoded) { bmp_bitmap_callback_vt bitmap_callbacks = { __bitmap_create, @@ -130,14 +130,18 @@ static int _read_bmp(const char *filename, void *memory, size_t src_size, mm_ima int res = MM_UTIL_ERROR_NONE; unsigned char *data = NULL; - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if(!MMUTIL_STRING_VALID(filename) && (memory == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path) && !memory, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); + + mm_util_fenter(); - if (filename) { - data = __load_file(filename, &size); + if (MMUTIL_STRING_VALID(file_path)) { + mm_util_sec_debug("read from file [%s]", file_path); + data = __load_file(file_path, &size); if (data == NULL) return MM_UTIL_ERROR_INVALID_OPERATION; } else { + mm_util_debug("read from memory"); data = (unsigned char *)memory; size = src_size; } @@ -162,23 +166,14 @@ static int _read_bmp(const char *filename, void *memory, size_t src_size, mm_ima } } - decoded->width = bmp.width; - decoded->height = bmp.height; - decoded->size = bmp.width * bmp.height * BYTES_PER_PIXEL; - decoded->data = calloc(1, decoded->size); - if (decoded->data == NULL) { - mm_util_error("Failed to saved memory allocation"); - res = MM_UTIL_ERROR_OUT_OF_MEMORY; - goto cleanup; - } - memcpy(decoded->data, bmp.bitmap, decoded->size); + res = mm_image_create_image(bmp.width, bmp.height, MM_UTIL_COLOR_RGBA, bmp.bitmap, bmp.width * bmp.height * BYTES_PER_PIXEL, decoded); cleanup: bmp_finalise(&bmp); - if (filename) + if (file_path) MMUTIL_SAFE_FREE(data); - mm_util_debug("width (%u) height (%u) size (%zu)", decoded->width, decoded->height, decoded->size); + mm_util_fleave(); return res; } @@ -233,40 +228,19 @@ static int _write_bmp(mm_image_info_s *decoded, const char *filename, void **mem return MM_UTIL_ERROR_NONE; } -int mm_util_decode_from_bmp_file(const char *filename, mm_image_info_s *decoded) +int mm_util_decode_from_bmp_file(const char *file_path, mm_util_image_h *decoded) { - int ret = MM_UTIL_ERROR_NONE; - - mm_util_retvm_if(!MMUTIL_STRING_VALID(filename), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - - mm_util_fenter(); - - ret = _read_bmp(filename, NULL, 0, decoded); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_read_bmp failed (%d)", ret); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); - mm_util_fleave(); - - return ret; + return __read_bmp(file_path, NULL, 0, decoded); } -int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_image_info_s *decoded) +int mm_util_decode_from_bmp_memory(void *memory, const size_t src_size, mm_util_image_h *decoded) { - int ret = MM_UTIL_ERROR_NONE; + mm_util_retvm_if(!memory, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); + mm_util_retvm_if(!src_size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src_size"); - mm_util_retvm_if((memory == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid bmp image"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - - mm_util_fenter(); - - ret = _read_bmp(NULL, memory, src_size, decoded); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_read_bmp failed (%d)", ret); - - mm_util_fleave(); - - return ret; + return __read_bmp(NULL, memory, src_size, decoded); } int mm_util_encode_bmp_to_file(mm_image_info_s *decoded, const char *filename) diff --git a/bmp/test/CMakeLists.txt b/bmp/test/CMakeLists.txt old mode 100755 new mode 100644 index 498ae6e..72cd751 --- a/bmp/test/CMakeLists.txt +++ b/bmp/test/CMakeLists.txt @@ -14,5 +14,5 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS} mmutil_common) ENDFOREACH() diff --git a/bmp/test/mm_util_bmp_testsuite.c b/bmp/test/mm_util_bmp_testsuite.c index 7a062ee..f3a371c 100644 --- a/bmp/test/mm_util_bmp_testsuite.c +++ b/bmp/test/mm_util_bmp_testsuite.c @@ -26,10 +26,12 @@ #include #include #include +#include #include #define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } #define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } +#define SAFE_IMAGE_FREE(x) { if (x != NULL) { mm_image_destroy_image(x); x = NULL; } } #define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_dec_file.raw") #define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_dec_mem.raw") @@ -57,12 +59,14 @@ static char *MODE_TO_STR[] = { /* for arguments */ static int g_test_mode = 0; static char *g_path = NULL; +static unsigned int g_width = 0; +static unsigned int g_height = 0; /* for reading file */ static void *g_readed_data = NULL; static size_t g_readed_size = 0; -static mm_image_info_s g_decoded_data = {0,}; +static mm_util_image_h g_decoded_data = NULL; static gboolean _read_file(char *path, void **data, size_t *length) { @@ -204,12 +208,12 @@ gboolean _get_arguments(int argc, char *argv[]) fprintf(stderr, "\t[BMP_testsuite] wrong width %s\n", argv[3]); return FALSE; } - g_decoded_data.width = (unsigned long)width; + g_width = (unsigned int)width; if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { fprintf(stderr, "\t[BMP_testsuite] wrong height %s\n", argv[4]); return FALSE; } - g_decoded_data.height = (unsigned long)height; + g_height = (unsigned int)height; } else { fprintf(stderr, "\t[BMP_testsuite] wrong mode for test %s\n", argv[1]); return FALSE; @@ -221,6 +225,8 @@ gboolean _get_arguments(int argc, char *argv[]) gboolean _test_decode(const bmp_test_mode_e mode) { int ret = 0; + unsigned char *data = NULL; + size_t size = 0; /* test decoding bmp */ if (mode == TEST_DECODE_FILE) { @@ -229,10 +235,17 @@ gboolean _test_decode(const bmp_test_mode_e mode) fprintf(stderr, "\t[BMP_testsuite] mm_util_decode_from_bmp_file failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, data, size)) { fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } else if (mode == TEST_DECODE_MEMORY) { if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[BMP_testsuite] reading file error\n"); @@ -244,10 +257,17 @@ gboolean _test_decode(const bmp_test_mode_e mode) fprintf(stderr, "\t[BMP_testsuite] mm_util_decode_from_bmp_memory failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, data, size)) { fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } return TRUE; @@ -263,21 +283,26 @@ gboolean _test_encode(const bmp_test_mode_e mode) if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) return TRUE; - if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_readed_size)) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[BMP_testsuite] reading file error\n"); return FALSE; } - g_decoded_data.size = (unsigned int)g_readed_size; + ret = mm_image_create_image(g_width, g_height, MM_UTIL_COLOR_RGBA, (unsigned char *)g_readed_data, + g_readed_size, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[BMP_testsuite] mm_image_create_image failed : %d\n", ret); + return FALSE; + } /* test encoding bmp */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_encode_bmp_to_file(&g_decoded_data, ENCODE_FILE_PATH); + ret = mm_util_encode_bmp_to_file((mm_image_info_s *)g_decoded_data, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[BMP_testsuite] mm_util_encode_bmp_to_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_bmp_to_memory(&g_decoded_data, &encoded_data, &encoded_size); + ret = mm_util_encode_bmp_to_memory((mm_image_info_s *)g_decoded_data, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[BMP_testsuite] mm_util_encode_bmp_to_memory failed : %d\n", ret); SAFE_FREE(encoded_data); @@ -327,7 +352,7 @@ gboolean _test_auto() fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); test_mode++; } @@ -372,7 +397,7 @@ int main(int argc, char *argv[]) out: SAFE_G_FREE(g_path); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); return 0; } diff --git a/bmp/unittest/libmm_bmp_unittest.cpp b/bmp/unittest/libmm_bmp_unittest.cpp index 7d44187..e17de0c 100644 --- a/bmp/unittest/libmm_bmp_unittest.cpp +++ b/bmp/unittest/libmm_bmp_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_bmp_unittest.h" #include "FileInterface.h" #include "mm_util_bmp.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-bmp-unittest.bmp") #define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "libmm-bmp-result.bmp") @@ -41,22 +42,19 @@ class libmm_bmp_Test : public ::testing::Test { TEST(libmm_bmp_Test, mm_util_decode_from_bmp_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_bmp_Test, mm_util_decode_from_bmp_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_bmp_file(NULL, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -69,7 +67,7 @@ TEST(libmm_bmp_Test, mm_util_decode_from_bmp_memory_p) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -77,19 +75,16 @@ TEST(libmm_bmp_Test, mm_util_decode_from_bmp_memory_p) ret = mm_util_decode_from_bmp_memory(IFile.readData, IFile.readDataSize, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_bmp_Test, mm_util_decode_from_bmp_memory_n) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -105,17 +100,16 @@ TEST(libmm_bmp_Test, mm_util_decode_from_bmp_memory_n) TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_bmp_to_file(&decode_image, ENCODE_FILE_PATH); + ret = mm_util_encode_bmp_to_file((mm_image_info_s *)decode_image, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_n) @@ -133,21 +127,20 @@ TEST(libmm_bmp_Test, mm_util_encode_bmp_to_file_n) TEST(libmm_bmp_Test, mm_util_encode_bmp_to_memory_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; ret = mm_util_decode_from_bmp_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_bmp_to_memory(&decode_image, &buffer, &size); + ret = mm_util_encode_bmp_to_memory((mm_image_info_s *)decode_image, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); if (buffer != NULL) free(buffer); diff --git a/gif/CMakeLists.txt b/gif/CMakeLists.txt index 24ac8f2..1c14ff1 100644 --- a/gif/CMakeLists.txt +++ b/gif/CMakeLists.txt @@ -38,7 +38,7 @@ SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}") aux_source_directory(. SOURCES) ADD_LIBRARY(${fw_name} SHARED ${SOURCES}) -TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS} gif) +TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS} gif mmutil_common) SET_TARGET_PROPERTIES(${fw_name} PROPERTIES VERSION ${VERSION} @@ -66,7 +66,7 @@ CONFIGURE_FILE( ) INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${PC_NAME}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) -#ADD_SUBDIRECTORY(test) +ADD_SUBDIRECTORY(test) IF(BUILD_GTESTS) ADD_SUBDIRECTORY(unittest) ENDIF(BUILD_GTESTS) diff --git a/gif/include/mm_util_gif.h b/gif/include/mm_util_gif.h index fb021bf..7d8aa86 100755 --- a/gif/include/mm_util_gif.h +++ b/gif/include/mm_util_gif.h @@ -49,8 +49,8 @@ typedef enum { typedef void* mm_gif_file_h; -int mm_util_decode_from_gif_file(const char *filename, mm_image_info_s * decoded); -int mm_util_decode_from_gif_memory(void *memory, const size_t src_size, mm_image_info_s * decoded); +int mm_util_decode_from_gif_file(const char *file_path, mm_util_image_h *decoded); +int mm_util_decode_from_gif_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); int mm_util_encode_to_gif_file(mm_image_info_s **images, const unsigned int image_count, const char *path); int mm_util_encode_to_gif_memory(mm_image_info_s **images, const unsigned int image_count, void **buffer, size_t *size); diff --git a/gif/mm_util_gif.c b/gif/mm_util_gif.c old mode 100644 new mode 100755 index 702b6b1..1bb6f30 --- a/gif/mm_util_gif.c +++ b/gif/mm_util_gif.c @@ -36,7 +36,7 @@ #define GRAPHIC_EXT_BLOCK_SIZE 4 -static int __convert_gif_to_rgba(void **data, ColorMapObject *color_map, GifRowType *screen_buffer, unsigned long width, unsigned long height) +static int __convert_gif_to_rgba(void **data, ColorMapObject *color_map, GifRowType *screen_buffer, unsigned int width, unsigned int height) { unsigned long i, j; GifRowType gif_row; @@ -79,7 +79,7 @@ static int __read_function(GifFileType *gft, GifByteType *data, int size) return size; } -static int __read_gif(mm_image_info_s *decoded, const char *filename, void *memory, const size_t src_size) +static int __read_gif(const char *file_path, void *memory, const size_t src_size, mm_util_image_h *decoded) { int ret = MM_UTIL_ERROR_NONE; @@ -91,15 +91,21 @@ static int __read_gif(mm_image_info_s *decoded, const char *filename, void *memo unsigned int image_num = 0; ColorMapObject *ColorMap; gif_mem_s read_data_ptr; + void *_data = NULL; + + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path) && (memory == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid gif image"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); mm_util_fenter(); - if (filename) { - if ((GifFile = DGifOpenFileName(filename, NULL)) == NULL) { + if (MMUTIL_STRING_VALID(file_path)) { + mm_util_sec_debug("read from file [%s]", file_path); + if ((GifFile = DGifOpenFileName(file_path, NULL)) == NULL) { mm_util_error("could not open Gif File"); return MM_UTIL_ERROR_INVALID_OPERATION; } - } else if (memory) { + } else { + mm_util_debug("read from memory"); read_data_ptr.mem = memory; read_data_ptr.mem_size = src_size; read_data_ptr.size = 0; @@ -107,20 +113,14 @@ static int __read_gif(mm_image_info_s *decoded, const char *filename, void *memo mm_util_error("could not open Gif File"); return MM_UTIL_ERROR_INVALID_OPERATION; } - } else { - mm_util_error("Gif File wrong decode parameters"); - return MM_UTIL_ERROR_INVALID_OPERATION; } + if (GifFile->SWidth <= 0 || GifFile->SHeight <= 0) { mm_util_error("Gif File wrong decode width & height"); return MM_UTIL_ERROR_INVALID_OPERATION; } - decoded->width = GifFile->SWidth; - decoded->height = GifFile->SHeight; - decoded->size = (unsigned long long)GifFile->SWidth * (unsigned long long)GifFile->SHeight * 4; - if ((screen_buffer = (GifRowType *) - calloc(1, GifFile->SHeight * sizeof(GifRowType))) == NULL) { + if ((screen_buffer = (GifRowType *)calloc(1, GifFile->SHeight * sizeof(GifRowType))) == NULL) { mm_util_error("Failed to allocate memory required, aborted."); ret = MM_UTIL_ERROR_INVALID_OPERATION; goto error; @@ -232,14 +232,16 @@ static int __read_gif(mm_image_info_s *decoded, const char *filename, void *memo goto error; } - ret = __convert_gif_to_rgba(&decoded->data, ColorMap, screen_buffer, GifFile->SWidth, GifFile->SHeight); + ret = __convert_gif_to_rgba(&_data, ColorMap, screen_buffer, GifFile->SWidth, GifFile->SHeight); if (ret != MM_UTIL_ERROR_NONE) { mm_util_error("could not convert gif to rgba"); ret = MM_UTIL_ERROR_INVALID_OPERATION; goto error; } - ret = MM_UTIL_ERROR_NONE; + ret = mm_image_create_image(GifFile->SWidth, GifFile->SHeight, MM_UTIL_COLOR_RGBA, _data, GifFile->SWidth * GifFile->SHeight * 4, decoded); + MMUTIL_SAFE_FREE(_data); + error: if (screen_buffer) { if (screen_buffer[0]) @@ -256,27 +258,23 @@ error: } mm_util_fleave(); + return ret; } -int mm_util_decode_from_gif_file(const char *fpath, mm_image_info_s *decoded) +int mm_util_decode_from_gif_file(const char *file_path, mm_util_image_h *decoded) { - mm_util_retvm_if(!MMUTIL_STRING_VALID(fpath), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fpath"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - - mm_util_fenter(); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); - return __read_gif(decoded, fpath, NULL, 0); + return __read_gif(file_path, NULL, 0, decoded); } -int mm_util_decode_from_gif_memory(void *memory, const size_t src_size, mm_image_info_s *decoded) +int mm_util_decode_from_gif_memory(void *memory, const size_t src_size, mm_util_image_h *decoded) { - mm_util_retvm_if(memory == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid memory"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - - mm_util_fenter(); + mm_util_retvm_if(!memory, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid memory"); + mm_util_retvm_if(!src_size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src_size"); - return __read_gif(decoded, NULL, memory, src_size); + return __read_gif(NULL, memory, src_size, decoded); } static int __write_function(GifFileType *gft, const GifByteType *data, int size) diff --git a/gif/test/CMakeLists.txt b/gif/test/CMakeLists.txt old mode 100755 new mode 100644 index 9ccd456..868a5fe --- a/gif/test/CMakeLists.txt +++ b/gif/test/CMakeLists.txt @@ -2,7 +2,7 @@ SET(fw_name "mmutil_gif") SET(fw_test "${fw_name}-test") INCLUDE(FindPkgConfig) -pkg_check_modules(${fw_test} REQUIRED glib-2.0 gmodule-2.0 dlog libtzplatform-config) +pkg_check_modules(${fw_test} REQUIRED glib-2.0 dlog libtzplatform-config) FOREACH(flag ${${fw_test}_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) @@ -14,5 +14,5 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS} mmutil_common) ENDFOREACH() diff --git a/gif/test/mm_util_gif_testsuite.c b/gif/test/mm_util_gif_testsuite.c index d23b4c1..a878fff 100644 --- a/gif/test/mm_util_gif_testsuite.c +++ b/gif/test/mm_util_gif_testsuite.c @@ -23,159 +23,380 @@ #include #include #include +#include #include #include +#include #include -#define ENCODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "encode_test.gif") -#define ANIMATED_FRAME_MAX 2 /* change the max frames for animated gif before using it */ +#define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } +#define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } +#define SAFE_IMAGE_FREE(x) { if (x != NULL) { mm_image_destroy_image(x); x = NULL; } } -static gboolean g_encode_mem = FALSE; +#define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "gif_test_dec_file.raw") +#define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "gif_test_dec_mem.raw") +#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "gif_test_enc_file.gif") +#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "gif_test_enc_mem.gif") -typedef struct { - char file_name[PATH_MAX]; - mm_image_info_s decoded; -} gif_test_data_s; +typedef enum { + TEST_AUTO, + TEST_DECODE_FILE, + TEST_DECODE_MEMORY, + TEST_ENCODE_FILE, + TEST_ENCODE_MEMORY, + TEST_NUM, +} bmp_test_mode_e; +static char *MODE_TO_STR[] = { + "AUTO", + "DECODE_FILE", + "DECODE_MEMORY", + "ENCODE_FILE", + "ENCODE_MEMORY", + "", +}; -static int _write_file(const char *file_name, void *data, size_t data_size) +/* for arguments */ +static int g_test_mode = 0; +static char *g_path = NULL; +static unsigned int g_width = 0; +static unsigned int g_height = 0; + +/* for reading file */ +static void *g_readed_data = NULL; +static size_t g_readed_size = 0; + +static mm_util_image_h g_decoded_data = NULL; + +static gboolean _read_file(char *path, void **data, size_t *length) { FILE *fp = NULL; + long len = 0; + + if (!path || !data || length == 0) { + fprintf(stderr, "\t[GIF_testsuite] invalid data %s %p %p\n", path, data, length); + return FALSE; + } + + fprintf(stderr, "\t[GIF_testsuite] %s read\n", path); + + fp = fopen(path, "r"); + if (fp == NULL) { + fprintf(stderr, "\t[GIF_testsuite] fopen failed (%d) \n", errno); + return FALSE; + } - fprintf(stderr, "\tdata %s %p size:%zu\n", file_name, data, data_size); + if (fseek(fp, 0, SEEK_END) < 0) { + fprintf(stderr, "\t[GIF_testsuite] fseek failed \n"); + fclose(fp); + return FALSE; + } - if (!file_name || !data || data_size == 0) { - fprintf(stderr, "\tinvalid data %s %p size:%zu\n", file_name, data, data_size); + len = ftell(fp); + if (len < 0) { + fprintf(stderr, "\t[GIF_testsuite] ftell failed \n"); + fclose(fp); return FALSE; } - fprintf(stderr, "\tTry to open %s to write\n", file_name); + rewind(fp); + *data = (void *)calloc(1, len); + if (*data == NULL) { + fprintf(stderr, "\tmemory allocation failed \n"); + fclose(fp); + return FALSE; + } - fp = fopen(file_name, "w"); + *length = fread(*data, 1, (size_t)len, fp); + if (*length != len) { + fprintf(stderr, "\t[GIF_testsuite] fread failed \n"); + } + + fclose(fp); + + if (*data == NULL) { + *length = 0; + return FALSE; + } + + *length = (size_t)len; + + fprintf(stderr, "\t[GIF_testsuite] %s %zu read DONE\n", path, *length); + + return TRUE; +} + +static gboolean _write_file(const char *path, void *data, size_t length) +{ + FILE *fp = NULL; + size_t len = 0; + + if (!path || !data || length == 0) { + fprintf(stderr, "\t[GIF_testsuite] invalid data %s %p %zu\n", path, data, length); + return FALSE; + } + + fprintf(stderr, "\t[GIF_testsuite] %s %p %zu write\n", path, data, length); + + fp = fopen(path, "w"); if (fp == NULL) { - fprintf(stderr, "\tfile open failed %d\n", errno); + fprintf(stderr, "\t[GIF_testsuite] fopen failed (%d) \n", errno); return FALSE; } - fwrite(data, 1, data_size, fp); + len = fwrite(data, 1, length, fp); + if (len != length) { + fprintf(stderr, "\t[GIF_testsuite] fwrite failed \n"); + } + fclose(fp); fp = NULL; - fprintf(stderr, "\tfile [%s] write DONE\n", file_name); + fprintf(stderr, "\t[GIF_testsuite] %s write DONE\n", path); return TRUE; } -static inline void flush_stdin() +gboolean _get_input_data(const char *argv, const long min, const long max, int *data) { - int ch; - while ((ch = getchar()) != EOF && ch != '\n') ; + if (argv == NULL || strlen(argv) == 0) + return FALSE; + + long temp = g_ascii_strtoll(argv, NULL, 10); + if (temp < min || temp > max) + return FALSE; + + *data = (int)temp; + + return TRUE; } -int main(int argc, char *argv[]) +void _print_help(const char *argv0) { - int ret = 0; - int i = 0, nfiles = 0; - gif_test_data_s files[ANIMATED_FRAME_MAX]; + fprintf(stderr, "\t[usage]\n"); + fprintf(stderr, "\t\t1. decode & encode : %s mode path\n", argv0); + fprintf(stderr, "\t\t2. decode : %s mode path\n", argv0); + fprintf(stderr, "\t\t3. encode : %s mode path width height\n", argv0); + fprintf(stderr, "\t\t4. mode : 0 - auto, 1 - decode from file, 2 - decode from memory, 3 - encode to file, 4 - encode to memeory\n"); +} - if (argc < 2) { - fprintf(stderr, "\t[usage]\n"); - fprintf(stderr, "\t\t1. decode : %s decode filepath\n", argv[0]); - fprintf(stderr, "\t\t2. encode-agif/encode-mem-agif : %s encode-agif dirpath\n", argv[0]); - return 0; +gboolean _get_arguments(int argc, char *argv[]) +{ + int width = 0, height = 0; + + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { + fprintf(stderr, "\t[GIF_testsuite] wrong mode(%s) for test\n", argv[1]); + _print_help(argv[0]); + return FALSE; } - if (!strcmp("decode", argv[1])) { - size_t nbytes = g_strlcpy(files[nfiles].file_name, argv[2], sizeof(files[nfiles].file_name)); - if (nbytes != strlen(argv[2])) { - fprintf(stderr, "\tERROR is occurred %x\n", ret); - return 0; - } - nfiles++; - } else if (!strcmp("encode-agif", argv[1]) || !strcmp("encode-mem-agif", argv[1])) { - if (!strcmp("encode-mem-agif", argv[1])) - g_encode_mem = TRUE; - - fprintf(stderr, "\tencode-agif %s\n", argv[1]); - struct dirent *dp = NULL; - DIR *fd = opendir(argv[2]); - int j = 0; - if (fd == NULL) { - fprintf(stderr, "\tlistdir: can't open %s\n", argv[2]); - return 0; - } - - while ((dp = readdir(fd)) != NULL) { - if (strlen(dp->d_name) == 0) - continue; - if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) - continue; /* skip self and parent */ - size_t nbytes = g_snprintf(files[nfiles].file_name, sizeof(files[nfiles].file_name), "%s%s", argv[2], dp->d_name); - if (nbytes == 0) - continue; - nfiles++; - } - closedir(fd); - - /* sort file name */ - char temp[PATH_MAX]; - for (i = 0; i < nfiles; i++) { - for (j = 0; j < nfiles - 1; j++) { - if ((strlen(files[j].file_name) > strlen(files[j + 1].file_name)) || - (strcmp(files[j].file_name, files[j + 1].file_name) > 0 && strlen(files[j].file_name) == strlen(files[j + 1].file_name))) { - memset(temp, 0, PATH_MAX); - g_strlcpy(temp, files[j].file_name, sizeof(temp)); - g_strlcpy(files[j].file_name, files[j + 1].file_name, sizeof(files[j].file_name)); - g_strlcpy(files[j + 1].file_name, temp, sizeof(files[j + 1].file_name)); - } - } + g_path = g_strdup(argv[2]); + if (g_path == NULL) { + fprintf(stderr, "\t[GIF_testsuite] Not enough memory\n"); + return FALSE; + } + + if ((g_test_mode == TEST_AUTO) || (g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + /* do nothing */ + } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) { + if (argc < 4) { + fprintf(stderr, "\t[GIF_testsuite] not enough args\n"); + _print_help(argv[0]); + return FALSE; } + if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &width)) { + fprintf(stderr, "\t[GIF_testsuite] wrong width %s\n", argv[3]); + return FALSE; + } + g_width = (unsigned int)width; + if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { + fprintf(stderr, "\t[GIF_testsuite] wrong height %s\n", argv[4]); + return FALSE; + } + g_height = (unsigned int)height; } else { - fprintf(stderr, "\tunknown command [%s]\n", argv[1]); - return 0; + fprintf(stderr, "\t[GIF_testsuite] wrong mode for test %s\n", argv[1]); + return FALSE; + } + + return TRUE; +} + +gboolean _test_decode(const bmp_test_mode_e mode) +{ + int ret = 0; + unsigned char *data = NULL; + size_t size = 0; + + /* test decoding gif */ + if (mode == TEST_DECODE_FILE) { + ret = mm_util_decode_from_gif_file(g_path, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_util_decode_from_bmp_file failed %d\n", ret); + return FALSE; + } + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, data, size)) { + fprintf(stderr, "\t[GIF_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + SAFE_FREE(data); + return FALSE; + } + SAFE_FREE(data); + } else if (mode == TEST_DECODE_MEMORY) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { + fprintf(stderr, "\t[GIF_testsuite] reading file error\n"); + return FALSE; + } + + ret = mm_util_decode_from_gif_memory(g_readed_data, g_readed_size, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_util_decode_from_bmp_memory failed %d\n", ret); + return FALSE; + } + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, data, size)) { + fprintf(stderr, "\t[GIF_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + SAFE_FREE(data); + return FALSE; + } + SAFE_FREE(data); } - fprintf(stderr, "\tnfiles: %d\n", nfiles); + return TRUE; +} + +gboolean _test_encode(const bmp_test_mode_e mode) +{ + int ret = 0; + /* for encoding gif to memory */ + void *encoded_data = NULL; + size_t encoded_size = 0; - for (i = 0; i < nfiles && i < ANIMATED_FRAME_MAX; i++) { - fprintf(stderr, "\tdecode %s\n", files[i].file_name); - ret = mm_util_decode_from_gif_file(files[i].file_name, &files[i].decoded); + if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) + return TRUE; + + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { + fprintf(stderr, "\t[GIF_testsuite] reading file error\n"); + return FALSE; + } + ret = mm_image_create_image(g_width, g_height, MM_UTIL_COLOR_RGBA, (unsigned char *)g_readed_data, g_readed_size, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_image_create_image failed : %d\n", ret); + return FALSE; + } + + /* test encoding gif */ + if (mode == TEST_ENCODE_FILE) { + ret = mm_util_encode_to_gif_file((mm_image_info_s **)&g_decoded_data, 1, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\tERROR is occurred %x to decode %s\n", ret, files[i].file_name); - continue; + fprintf(stderr, "\t[GIF_testsuite] mm_util_encode_gif_to_file failed : %d\n", ret); + return FALSE; + } + } else if (mode == TEST_ENCODE_MEMORY) { + ret = mm_util_encode_to_gif_memory((mm_image_info_s **)&g_decoded_data, 1, &encoded_data, &encoded_size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[GIF_testsuite] mm_util_encode_gif_to_memory failed : %d\n", ret); + SAFE_FREE(encoded_data); + return FALSE; + } + if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, encoded_size)) { + fprintf(stderr, "\t[GIF_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH); + SAFE_FREE(encoded_data); + return FALSE; } } - mm_gif_file_h gif_file = NULL; - unsigned char *encoded_gif_mem = NULL; - size_t encoded_gif_size = 0; + SAFE_FREE(encoded_data); + return TRUE; +} - ret = mm_util_gif_encode_create(&gif_file); - fprintf(stderr, "\t mm_util_gif_enc_create [%d]\n", ret); - if (g_encode_mem) { - ret = mm_util_gif_encode_set_mem(gif_file, (void **)&encoded_gif_mem, &encoded_gif_size); - fprintf(stderr, "\t mm_util_gif_encode_set_mem [%d]\n", ret); - } else { - ret = mm_util_gif_encode_set_file(gif_file, ENCODE_RESULT_PATH); - fprintf(stderr, "\t mm_util_gif_enc_set_file [%d]\n", ret); +gboolean _test_auto() +{ + bmp_test_mode_e test_mode = TEST_DECODE_FILE; + + while (test_mode < TEST_NUM) { + fprintf(stderr, "\t[GIF_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST START\n", MODE_TO_STR[test_mode]); + if (TEST_ENCODE_FILE == test_mode) { + SAFE_G_FREE(g_path); + g_path = g_strdup(DECODE_FILE_PATH); + if (g_path == NULL) { + fprintf(stderr, "\t[GIF_testsuite] Not enough memory\n"); + return FALSE; + } + } + /* test decoding gif */ + if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(test_mode)) { + fprintf(stderr, "\t[GIF_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + /* test encoding gif */ + if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(test_mode)) { + fprintf(stderr, "\t[GIF_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]); + return FALSE; + } + } + + fprintf(stderr, "\t[GIF_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); + + SAFE_FREE(g_readed_data); + SAFE_IMAGE_FREE(g_decoded_data); + test_mode++; + } + + return TRUE; +} + +int main(int argc, char *argv[]) +{ + if (argc < 2) { + _print_help(argv[0]); + return 0; } - /* repeat */ - for (i = 0; i < nfiles; i++) { - if (files[i].decoded.data) { - files[i].decoded.delay_time = 50; - ret = mm_util_gif_encode_add_image(gif_file, &(files[i].decoded)); - fprintf(stderr, "\t mm_util_gif_enc_add_image [%d]\n", ret); + if (FALSE == _get_arguments(argc, argv)) { + fprintf(stderr, "\t[GIF_testsuite] _get_arguments failed\n"); + goto out; + } + + /* test all functions automatically */ + if (g_test_mode == TEST_AUTO) { + if (FALSE == _test_auto()) + fprintf(stderr, "\t[GIF_testsuite] _test_auto failed\n"); + goto out; + } - free(files[i].decoded.data); + /* test decoding gif */ + if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { + if (FALSE == _test_decode(g_test_mode)) { + fprintf(stderr, "\t[GIF_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; } } - /* repeat */ - ret = mm_util_gif_encode_save(gif_file); - fprintf(stderr, "\t mm_util_gif_enc_save [%d]\n", ret); - if (g_encode_mem) - _write_file(ENCODE_RESULT_PATH, (void *)encoded_gif_mem, (size_t)encoded_gif_size); - mm_util_gif_encode_destroy(gif_file); + + /* test encoding gif */ + if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) { + if (FALSE == _test_encode(g_test_mode)) { + fprintf(stderr, "\t[GIF_testsuite] _test_encode(%s) failed\n", MODE_TO_STR[g_test_mode]); + goto out; + } + } + +out: + SAFE_G_FREE(g_path); + SAFE_FREE(g_readed_data); + SAFE_IMAGE_FREE(g_decoded_data); return 0; } diff --git a/gif/unittest/libmm_gif_unittest.cpp b/gif/unittest/libmm_gif_unittest.cpp index 4910b0c..296f09f 100644 --- a/gif/unittest/libmm_gif_unittest.cpp +++ b/gif/unittest/libmm_gif_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_gif_unittest.h" #include "FileInterface.h" #include "mm_util_gif.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-gif-unittest.gif") #define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "libmm-gif-result.gif") @@ -41,22 +42,19 @@ class libmm_gif_Test : public ::testing::Test { TEST(libmm_gif_Test, mm_util_decode_from_gif_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_gif_Test, mm_util_decode_from_gif_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_gif_file(NULL, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -69,7 +67,7 @@ TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_p) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -77,19 +75,16 @@ TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_p) ret = mm_util_decode_from_gif_memory(IFile.readData, IFile.readDataSize, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_n) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -105,18 +100,16 @@ TEST(libmm_gif_Test, mm_util_decode_from_gif_memory_n) TEST(libmm_gif_Test, mm_util_encode_to_gif_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; - mm_image_info_s *ptr_decode_image = &decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_gif_file(&ptr_decode_image, 1, ENCODE_FILE_PATH); + ret = mm_util_encode_to_gif_file((mm_image_info_s **)&decode_image, 1, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_gif_Test, mm_util_encode_to_gif_file_n) @@ -135,22 +128,20 @@ TEST(libmm_gif_Test, mm_util_encode_to_gif_file_n) TEST(libmm_gif_Test, mm_util_encode_to_gif_memory_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; - mm_image_info_s *ptr_decode_image = &decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; ret = mm_util_decode_from_gif_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_gif_memory(&ptr_decode_image, 1, &buffer, &size); + ret = mm_util_encode_to_gif_memory((mm_image_info_s **)&decode_image, 1, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); if (buffer != NULL) free(buffer); diff --git a/imgcv/test/CMakeLists.txt b/imgcv/test/CMakeLists.txt old mode 100755 new mode 100644 index 8748493..e94f9aa --- a/imgcv/test/CMakeLists.txt +++ b/imgcv/test/CMakeLists.txt @@ -14,5 +14,5 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${JPEG-LIB} ${${fw_test}_LDFLAGS} mmutil_jpeg) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${JPEG-LIB} ${${fw_test}_LDFLAGS} mmutil_jpeg mmutil_common) ENDFOREACH() diff --git a/imgcv/test/mm_util_imgcv_testsuite.c b/imgcv/test/mm_util_imgcv_testsuite.c old mode 100755 new mode 100644 index 92acf84..e2fbf90 --- a/imgcv/test/mm_util_imgcv_testsuite.c +++ b/imgcv/test/mm_util_imgcv_testsuite.c @@ -23,6 +23,7 @@ #include #include +#include #include #define MAX_FILENAME_LEN 1024 @@ -30,11 +31,11 @@ int main(int argc, char *argv[]) { int ret = 0; - int width; - int height; + unsigned int width; + unsigned int height; unsigned char *img_buffer; - unsigned int img_buffer_size; + size_t img_buffer_size; if (argc < 1) { fprintf(stderr, "Usage: ./mm_imgcv_testsuite filename(jpg format only)\n"); @@ -48,18 +49,14 @@ int main(int argc, char *argv[]) } /* decode jpg image */ - mm_image_info_s decoded; - memset(&decoded, 0, sizeof(mm_image_info_s)); + mm_util_image_h decoded = NULL; ret = mm_util_decode_from_jpeg_file(argv[1], MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decoded); if (!ret) { - img_buffer = decoded.data; - width = decoded.width; - height = decoded.height; - img_buffer_size = decoded.size; - fprintf(stderr, "Success - buffer[%p], width[%d], height[%d], size[%d]", - img_buffer, width, height, img_buffer_size); + ret = mm_image_get_image(decoded, &width, &height, NULL, &img_buffer, &img_buffer_size); + fprintf(stderr, "Success[%d] - buffer[%p], width[%u], height[%u], size[%zu]", + ret, img_buffer, width, height, img_buffer_size); } else { fprintf(stderr, "ERROR - Fail to decode jpeg image file"); return ret; @@ -67,13 +64,14 @@ int main(int argc, char *argv[]) /* extract color */ unsigned char rgb_r, rgb_g, rgb_b; - ret = mm_util_cv_extract_representative_color(img_buffer, width, height, &rgb_r, &rgb_g, &rgb_b); + ret = mm_util_cv_extract_representative_color(img_buffer, (int)width, (int)height, &rgb_r, &rgb_g, &rgb_b); if (!ret) fprintf(stderr, "Success - R[%d], G[%d], B[%d]", rgb_r, rgb_g, rgb_b); else fprintf(stderr, "Error - fail to extract color"); + mm_image_destroy_image(decoded); free(img_buffer); img_buffer = NULL; diff --git a/imgcv/unittest/libmm_imgcv_unittest.cpp b/imgcv/unittest/libmm_imgcv_unittest.cpp index 73c5f00..6b1394e 100644 --- a/imgcv/unittest/libmm_imgcv_unittest.cpp +++ b/imgcv/unittest/libmm_imgcv_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_imgcv_unittest.h" #include "mm_util_jpeg.h" #include "mm_util_imgcv.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-imgcv-unittest.jpg") @@ -40,20 +41,26 @@ class libmm_imgcv_Test : public ::testing::Test { TEST(libmm_imgcv_Test, mm_util_cv_extract_representative_color_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; + unsigned int width = 0; + unsigned int height = 0; + unsigned char *data = NULL; + size_t size = 0; unsigned char r_color; unsigned char g_color; unsigned char b_color; ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); + + ret = mm_image_get_image(decode_image, &width, &height, NULL, &data, &size); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - ret = mm_util_cv_extract_representative_color(decode_image.data, decode_image.width, decode_image.height, &r_color, &g_color, &b_color); + ret = mm_util_cv_extract_representative_color(data, width, height, &r_color, &g_color, &b_color); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - if (decode_image.data) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_imgcv_Test, mm_util_cv_extract_representative_color_n) diff --git a/imgp/unittest/libmm_imgp_unittest.cpp b/imgp/unittest/libmm_imgp_unittest.cpp index 190a090..521aebd 100644 --- a/imgp/unittest/libmm_imgp_unittest.cpp +++ b/imgp/unittest/libmm_imgp_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_imgp_unittest.h" #include "mm_util_jpeg.h" #include "mm_util_imgp.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-imgp-unittest.jpg") @@ -40,15 +41,19 @@ class libmm_imgp_Test : public ::testing::Test { TEST(libmm_imgp_Test, mm_util_convert_colorspace_p) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); @@ -57,6 +62,7 @@ TEST(libmm_imgp_Test, mm_util_convert_colorspace_p) EXPECT_EQ(height, 480); EXPECT_NE(size, 0); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); if (data) @@ -66,15 +72,19 @@ TEST(libmm_imgp_Test, mm_util_convert_colorspace_p) TEST(libmm_imgp_Test, mm_util_convert_colorspace_n) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_convert_colorspace(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -91,6 +101,7 @@ TEST(libmm_imgp_Test, mm_util_convert_colorspace_n) ret = mm_util_convert_colorspace((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_COLOR_RGB24, &data, &width, &height, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); } @@ -98,15 +109,19 @@ TEST(libmm_imgp_Test, mm_util_convert_colorspace_n) TEST(libmm_imgp_Test, mm_util_resize_image_p) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); @@ -115,6 +130,7 @@ TEST(libmm_imgp_Test, mm_util_resize_image_p) EXPECT_EQ(height, 240); EXPECT_NE(size, 0); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); if (data) @@ -124,15 +140,19 @@ TEST(libmm_imgp_Test, mm_util_resize_image_p) TEST(libmm_imgp_Test, mm_util_resize_image_n) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_resize_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -155,6 +175,7 @@ TEST(libmm_imgp_Test, mm_util_resize_image_n) ret = mm_util_resize_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 320, 240, &data, &width, &height, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); } @@ -162,15 +183,19 @@ TEST(libmm_imgp_Test, mm_util_resize_image_n) TEST(libmm_imgp_Test, mm_util_rotate_image_p) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); @@ -179,6 +204,7 @@ TEST(libmm_imgp_Test, mm_util_rotate_image_p) EXPECT_EQ(height, 640); EXPECT_NE(size, 0); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); if (data) @@ -188,15 +214,19 @@ TEST(libmm_imgp_Test, mm_util_rotate_image_p) TEST(libmm_imgp_Test, mm_util_rotate_image_n) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_rotate_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -213,6 +243,7 @@ TEST(libmm_imgp_Test, mm_util_rotate_image_n) ret = mm_util_rotate_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, MM_UTIL_ROTATE_90, &data, &width, &height, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); } @@ -220,15 +251,19 @@ TEST(libmm_imgp_Test, mm_util_rotate_image_n) TEST(libmm_imgp_Test, mm_util_crop_image_p) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_ARGB, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); @@ -237,6 +272,7 @@ TEST(libmm_imgp_Test, mm_util_crop_image_p) EXPECT_EQ(height, 240); EXPECT_NE(size, 0); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); if (data) @@ -246,15 +282,19 @@ TEST(libmm_imgp_Test, mm_util_crop_image_p) TEST(libmm_imgp_Test, mm_util_crop_image_n) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h decode_image_h = NULL; mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; unsigned char *data = NULL; unsigned int width = 0; unsigned int height = 0; size_t size = 0;; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_ARGB, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image_h); + EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); + EXPECT_TRUE(mm_image_is_valid_image(decode_image_h)); + + ret = mm_image_get_image(decode_image_h, &decode_image.width, &decode_image.height, NULL, (unsigned char **)&decode_image.data, &decode_image.size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); ret = mm_util_crop_image(NULL, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -277,6 +317,7 @@ TEST(libmm_imgp_Test, mm_util_crop_image_n) ret = mm_util_crop_image((const unsigned char *)decode_image.data, decode_image.width, decode_image.height, MM_UTIL_COLOR_ARGB, 0, 0, 320, 240, &data, &width, &height, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); + mm_image_destroy_image(decode_image_h); if (decode_image.data) free(decode_image.data); } diff --git a/jpeg/include/mm_util_jpeg.h b/jpeg/include/mm_util_jpeg.h index 1d51438..b6a9a42 100755 --- a/jpeg/include/mm_util_jpeg.h +++ b/jpeg/include/mm_util_jpeg.h @@ -49,8 +49,8 @@ typedef enum { int mm_util_jpeg_encode_to_file(mm_image_info_s *decoded, int quality, const char *filename); int mm_util_jpeg_encode_to_memory(void **mem, unsigned int *size, unsigned char *src, unsigned int width, unsigned int height, mm_util_color_format_e color, int quality); int mm_util_encode_to_jpeg_memory(mm_image_info_s *decoded, int quality, void **mem, size_t *size); -int mm_util_decode_from_jpeg_file(const char *filename, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_image_info_s *decoded); -int mm_util_decode_from_jpeg_memory(void *src, const size_t size, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_image_info_s *decoded); +int mm_util_decode_from_jpeg_file(const char *file_path, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded); +int mm_util_decode_from_jpeg_memory(void *memory, const size_t src_size, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded); #ifdef __cplusplus diff --git a/jpeg/mm_util_jpeg.c b/jpeg/mm_util_jpeg.c index 8a8e639..a50eb0d 100755 --- a/jpeg/mm_util_jpeg.c +++ b/jpeg/mm_util_jpeg.c @@ -282,22 +282,24 @@ static int __mm_image_encode_with_libjpeg(mm_util_jpeg_cont_format_e control_for return iErrorCode; } -static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_format, FILE *fp, void *src, size_t size, mm_util_color_format_e color_format, mm_util_jpeg_decode_downscale downscale, mm_image_info_s *decoded_data) +static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_format, FILE *fp, void *src, size_t size, mm_util_color_format_e color_format, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded) { - int iErrorCode = MM_UTIL_ERROR_NONE; + int ret = MM_UTIL_ERROR_NONE; struct jpeg_decompress_struct dinfo; struct my_error_mgr_s jerr; JSAMPARRAY buffer; /* Output row buffer */ int row_stride = 0; /* physical row width in output buffer */ JSAMPROW image, u_image, v_image; JSAMPROW row; /* point to buffer[0] */ + size_t _size = 0; + void *_data = NULL; mm_util_fenter(); - mm_util_retvm_if(decoded_data == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid decoded_data"); mm_util_retvm_if((control_format != MM_UTIL_JPEG_FILE) && (control_format != MM_UTIL_JPEG_MEM), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid control_format [%u]", control_format); mm_util_retvm_if((control_format == MM_UTIL_JPEG_FILE) && (fp == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fp"); mm_util_retvm_if((control_format == MM_UTIL_JPEG_MEM) && ((src == NULL) || (size == 0)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src or size"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); /* allocate and initialize JPEG decompression object We set up the normal JPEG error routines, then override error_exit. */ dinfo.err = jpeg_std_error(&jerr.pub); @@ -368,7 +370,6 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for dinfo.out_color_space = JCS_EXT_ARGB; mm_util_debug("cinfo.out_color_space = JCS_EXT_ARGB"); } - decoded_data->color = color_format; /* Start decompressor */ jpeg_start_decompress(&dinfo); @@ -388,16 +389,15 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for /* Make a one-row-high sample array that will go away when done with image */ buffer = (*dinfo.mem->alloc_sarray) ((j_common_ptr) &dinfo, JPOOL_IMAGE, row_stride, 1); mm_util_debug("JPOOL_IMAGE BUFFER (color_format: %d)", color_format); - decoded_data->width = dinfo.output_width; - decoded_data->height = dinfo.output_height; + if (color_format == MM_UTIL_COLOR_RGB24 || color_format == MM_UTIL_COLOR_RGBA || color_format == MM_UTIL_COLOR_BGRA || color_format == MM_UTIL_COLOR_ARGB) { - decoded_data->size = dinfo.output_height * row_stride; + _size = dinfo.output_height * row_stride; } else if (color_format == MM_UTIL_COLOR_YUV420) { - decoded_data->size = dinfo.output_height * row_stride / 2; + _size = dinfo.output_height * row_stride / 2; } else if (color_format == MM_UTIL_COLOR_YUV422 || color_format == MM_UTIL_COLOR_UYVY) { - decoded_data->size = dinfo.output_height * dinfo.output_width * 2; + _size = dinfo.output_height * dinfo.output_width * 2; } else if (color_format == MM_UTIL_COLOR_GRAYSCALE) { - decoded_data->size = dinfo.output_height * dinfo.output_width; + _size = dinfo.output_height * dinfo.output_width; } else{ jpeg_finish_decompress(&dinfo); jpeg_destroy_decompress(&dinfo); @@ -405,20 +405,18 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for return MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT; } - decoded_data->data = (void *) calloc(1, decoded_data->size); - decoded_data->color = color_format; - - if (decoded_data->data == NULL) { + _data = (void *) calloc(1, _size); + if (!_data) { jpeg_finish_decompress(&dinfo); jpeg_destroy_decompress(&dinfo); - mm_util_error("decoded_data->data is NULL"); + mm_util_error("_data is NULL"); return MM_UTIL_ERROR_OUT_OF_MEMORY; } mm_util_debug("decoded_data->data"); /* while (scan lines remain to be read) jpeg_read_scanlines(...); */ if (color_format == MM_UTIL_COLOR_YUV420 || color_format == MM_UTIL_COLOR_YUV422 || color_format == MM_UTIL_COLOR_UYVY) { - image = decoded_data->data; + image = _data; u_image = image + (dinfo.output_width * dinfo.output_height); v_image = u_image + (dinfo.output_width*dinfo.output_height)/4; row = buffer[0]; @@ -445,12 +443,15 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for /* jpeg_read_scanlines expects an array of pointers to scanlines. Here the array is only one element long, but you could ask formore than one scanline at a time if that's more convenient. */ jpeg_read_scanlines(&dinfo, buffer, 1); - memcpy(decoded_data->data + state, buffer[0], row_stride); + memcpy(_data + state, buffer[0], row_stride); state += row_stride; } mm_util_debug("jpeg_read_scanlines"); } + ret = mm_image_create_image(dinfo.output_width, dinfo.output_height, color_format, _data, _size, decoded); + MMUTIL_SAFE_FREE(_data); + /* Finish decompression */ jpeg_finish_decompress(&dinfo); mm_util_debug("jpeg_finish_decompress"); @@ -461,7 +462,21 @@ static int __mm_image_decode_with_libjpeg(mm_util_jpeg_cont_format_e control_for mm_util_fleave(); - return iErrorCode; + return ret; +} + +static int __mm_util_jpeg_convert_colorspace(mm_util_image_h image, mm_util_image_h *converted) +{ + int ret = MM_UTIL_ERROR_NONE; + mm_image_info_s *_image = (mm_image_info_s *)image; + unsigned int dst_w = 0, dst_h = 0; + unsigned char *dst_data = NULL; + size_t dst_data_size = 0; + + ret = mm_util_convert_colorspace(_image->data, _image->width, _image->height, MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NV12, &dst_data, &dst_w, &dst_h, &dst_data_size); + mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "fail to mm_util_convert_colorspace [%d]", ret); + + return mm_image_create_image(dst_w, dst_h, MM_UTIL_COLOR_NV12, dst_data, dst_data_size, converted); } int mm_util_jpeg_encode_to_file(mm_image_info_s *decoded, int quality, const char *filename) @@ -568,16 +583,18 @@ int mm_util_encode_to_jpeg_memory(mm_image_info_s *decoded, int quality, void ** return ret; } -int mm_util_decode_from_jpeg_file(const char *filename, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_image_info_s *decoded) +int mm_util_decode_from_jpeg_file(const char *file_path, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded) { int ret = MM_UTIL_ERROR_NONE; + FILE *fp = NULL; + mm_util_image_h _decoded = NULL; mm_util_fenter(); - mm_util_retvm_if(decoded == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid decoded"); - mm_util_retvm_if(filename == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid filename"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); mm_util_retvm_if((IS_VALID_COLOR(fmt) == FALSE), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fmt [%d]", fmt); mm_util_retvm_if((!_mm_util_is_supported_color_format(fmt)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported fmt [%d]", fmt); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); if ((downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_2) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_4) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8)) { @@ -585,31 +602,17 @@ int mm_util_decode_from_jpeg_file(const char *filename, mm_util_color_format_e f return MM_UTIL_ERROR_INVALID_PARAMETER; } - FILE *fp = NULL; - ret = mm_util_safe_fopen(filename, "rb", &fp); + ret = mm_util_safe_fopen(file_path, "rb", &fp); mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "mm_util_safe_fopen fail (%d)", ret); - mm_util_debug("#START# libjpeg fmt [%d]", fmt); if (fmt == MM_UTIL_COLOR_NV12) { - ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_FILE, fp, NULL, 0, MM_UTIL_COLOR_YUV420, downscale, decoded); - if (ret == MM_UTIL_ERROR_NONE) { - unsigned int res_w = 0; - unsigned int res_h = 0; - size_t res_buffer_size = 0; - unsigned char *dst = NULL; - - ret = mm_util_convert_colorspace(decoded->data, decoded->width, decoded->height, MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NV12, &dst, &res_w, &res_h, &res_buffer_size); - - MMUTIL_SAFE_FREE(decoded->data); - - decoded->data = dst; - decoded->size = res_buffer_size; - } + ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_FILE, fp, NULL, 0, MM_UTIL_COLOR_YUV420, downscale, &_decoded); + if (ret == MM_UTIL_ERROR_NONE) + ret = __mm_util_jpeg_convert_colorspace(_decoded, decoded); + mm_image_destroy_image(_decoded); } else { ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_FILE, fp, NULL, 0, fmt, downscale, decoded); } - mm_util_debug("decoded->data: %p\t width: %u\t height: %u\t size: %zu", decoded->data, decoded->width, decoded->height, decoded->size); - mm_util_debug("#End# libjpeg, Success!! ret: %d", ret); mm_util_safe_fclose(fp); @@ -618,16 +621,18 @@ int mm_util_decode_from_jpeg_file(const char *filename, mm_util_color_format_e f return ret; } -int mm_util_decode_from_jpeg_memory(void *src, const size_t size, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_image_info_s *decoded) +int mm_util_decode_from_jpeg_memory(void *memory, const size_t src_size, mm_util_color_format_e fmt, mm_util_jpeg_decode_downscale downscale, mm_util_image_h *decoded) { int ret = MM_UTIL_ERROR_NONE; + mm_util_image_h _decoded = NULL; mm_util_fenter(); - mm_util_retvm_if(decoded == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid decoded"); - mm_util_retvm_if(src == NULL, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid filename"); + mm_util_retvm_if(!memory, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid jpeg image"); + mm_util_retvm_if(!src_size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src_size"); mm_util_retvm_if((IS_VALID_COLOR(fmt) == FALSE), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid fmt [%d]", fmt); mm_util_retvm_if((!_mm_util_is_supported_color_format(fmt)), MM_UTIL_ERROR_NOT_SUPPORTED_FORMAT, "not supported fmt [%d]", fmt); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); if ((downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_2) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_4) && (downscale != MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8)) { @@ -635,27 +640,15 @@ int mm_util_decode_from_jpeg_memory(void *src, const size_t size, mm_util_color_ return MM_UTIL_ERROR_INVALID_PARAMETER; } - mm_util_debug("#START# libjpeg"); if (fmt == MM_UTIL_COLOR_NV12) { - ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, src, size, MM_UTIL_COLOR_YUV420, downscale, decoded); - if (ret == MM_UTIL_ERROR_NONE) { - unsigned int res_w = 0; - unsigned int res_h = 0; - size_t res_buffer_size = 0; - unsigned char *dst = NULL; - - ret = mm_util_convert_colorspace(decoded->data, decoded->width, decoded->height, MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NV12, &dst, &res_w, &res_h, &res_buffer_size); - - MMUTIL_SAFE_FREE(decoded->data); - - decoded->data = dst; - decoded->size = res_buffer_size; - } + ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, memory, src_size, MM_UTIL_COLOR_YUV420, downscale, &_decoded); + if (ret == MM_UTIL_ERROR_NONE) + ret = __mm_util_jpeg_convert_colorspace(_decoded, decoded); + mm_image_destroy_image(_decoded); } else { - ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, src, size, fmt, downscale, decoded); + ret = __mm_image_decode_with_libjpeg(MM_UTIL_JPEG_MEM, NULL, memory, src_size, fmt, downscale, decoded); } - mm_util_debug("decoded->data: %p\t width: %u\t height: %u\t size: %zu", decoded->data, decoded->width, decoded->height, decoded->size); - mm_util_debug("#END# libjpeg, Success!! ret: %d", ret); + mm_util_fleave(); return ret; diff --git a/jpeg/test/CMakeLists.txt b/jpeg/test/CMakeLists.txt old mode 100755 new mode 100644 index 0cf2e46..ee8e76a --- a/jpeg/test/CMakeLists.txt +++ b/jpeg/test/CMakeLists.txt @@ -14,5 +14,5 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS} mmutil_common) ENDFOREACH() diff --git a/jpeg/test/mm_util_jpeg_testsuite.c b/jpeg/test/mm_util_jpeg_testsuite.c index 5bdf8ca..9a8be07 100644 --- a/jpeg/test/mm_util_jpeg_testsuite.c +++ b/jpeg/test/mm_util_jpeg_testsuite.c @@ -26,10 +26,12 @@ #include #include #include +#include #include #define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } #define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } +#define SAFE_IMAGE_FREE(x) { if (x != NULL) { mm_image_destroy_image(x); x = NULL; } } #define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_dec_file.raw") #define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_dec_mem.raw") @@ -57,6 +59,8 @@ static char *MODE_TO_STR[] = { /* for arguments */ static int g_test_mode = 0; static char *g_path = NULL; +static unsigned int g_width = 0; +static unsigned int g_height = 0; static int g_color = MM_UTIL_COLOR_RGB24; static int g_quality = 75; static int g_downscale = MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1; @@ -65,7 +69,7 @@ static int g_downscale = MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1; static void *g_readed_data = NULL; static size_t g_readed_size = 0; -static mm_image_info_s g_decoded_data = {0,}; +static mm_util_image_h g_decoded_data = NULL; static gboolean _read_file(char *path, void **data, size_t *length) { @@ -181,6 +185,8 @@ void _print_help(const char *argv0) gboolean _get_arguments(int argc, char *argv[]) { + int width = 0, height = 0; + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { fprintf(stderr, "\t[JPEG_testsuite] wrong mode(%s) for test\n", argv[1]); _print_help(argv[0]); @@ -198,7 +204,8 @@ gboolean _get_arguments(int argc, char *argv[]) fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color); if (FALSE == _get_input_data(argv[4], 1, 100, &g_quality)) fprintf(stderr, "\t[JPEG_testsuite] quality is default(%d)\n", g_quality); - if (FALSE == _get_input_data(argv[5], MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8, &g_downscale)) + /* min: MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, max: MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8 */ + if (FALSE == _get_input_data(argv[5], 1, 8, &g_downscale)) fprintf(stderr, "\t[JPEG_testsuite] downscale is default(%d)\n", g_downscale); } else if (g_test_mode == TEST_DECODE_FILE) { if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) @@ -212,14 +219,16 @@ gboolean _get_arguments(int argc, char *argv[]) _print_help(argv[0]); return FALSE; } - if (FALSE == _get_input_data(argv[3], 0, INT_MAX, (int *)&g_decoded_data.width)) { + if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &width)) { fprintf(stderr, "\t[JPEG_testsuite] wrong width %s\n", argv[3]); return FALSE; } - if (FALSE == _get_input_data(argv[4], 0, INT_MAX, (int *)&g_decoded_data.height)) { + g_width = (unsigned int)width; + if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { fprintf(stderr, "\t[JPEG_testsuite] wrong height %s\n", argv[4]); return FALSE; } + g_height = (unsigned int)height; if (FALSE == _get_input_data(argv[5], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color)) { fprintf(stderr, "\t[JPEG_testsuite] wrong color %s\n", argv[5]); return FALSE; @@ -227,7 +236,8 @@ gboolean _get_arguments(int argc, char *argv[]) if (FALSE == _get_input_data(argv[6], 1, 100, &g_quality)) fprintf(stderr, "\t[JPEG_testsuite] quality is default(%d)\n", g_quality); - if (FALSE == _get_input_data(argv[7], MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8, &g_downscale)) + /* min: MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, max: MM_UTIL_JPEG_DECODE_DOWNSCALE_1_8 */ + if (FALSE == _get_input_data(argv[7], 1, 8, &g_downscale)) fprintf(stderr, "\t[JPEG_testsuite] downscale is default(%d)\n", g_downscale); } else { fprintf(stderr, "\t[JPEG_testsuite] wrong mode for test %s\n", argv[1]); @@ -240,18 +250,27 @@ gboolean _get_arguments(int argc, char *argv[]) gboolean _test_decode(const jpeg_test_mode_e mode) { int ret = 0; + unsigned char *data = NULL; + size_t size = 0; /* test decoding jpeg */ if (mode == TEST_DECODE_FILE) { ret = mm_util_decode_from_jpeg_file(g_path, g_color, g_downscale, &g_decoded_data); if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_file_with_downscale failed %d\n", ret); + fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_file failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, data, size)) { fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } else if (mode == TEST_DECODE_MEMORY) { if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[JPEG_testsuite] reading file error\n"); @@ -260,13 +279,20 @@ gboolean _test_decode(const jpeg_test_mode_e mode) ret = mm_util_decode_from_jpeg_memory(g_readed_data, g_readed_size, g_color, g_downscale, &g_decoded_data); if (ret != MM_UTIL_ERROR_NONE) { - fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_memory_with_downscale failed %d\n", ret); + fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_memory failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, data, size)) { fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } return TRUE; @@ -282,21 +308,26 @@ gboolean _test_encode(const jpeg_test_mode_e mode) if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) return TRUE; - if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_decoded_data.size)) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[JPEG_testsuite] reading file error\n"); return FALSE; } - g_decoded_data.color = (mm_util_color_format_e)g_color; + ret = mm_image_create_image(g_width, g_height, g_color, (unsigned char *)g_readed_data, + g_readed_size, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[JPEG_testsuite] mm_image_create_image failed : %d\n", ret); + return FALSE; + } /* test encoding jpeg */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_jpeg_encode_to_file(&g_decoded_data, g_quality, ENCODE_FILE_PATH); + ret = mm_util_jpeg_encode_to_file((mm_image_info_s *)g_decoded_data, g_quality, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_to_jpeg_memory(&g_decoded_data, g_quality, &encoded_data, &encoded_size); + ret = mm_util_encode_to_jpeg_memory((mm_image_info_s *)g_decoded_data, g_quality, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[JPEG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret); SAFE_FREE(encoded_data); @@ -346,7 +377,7 @@ gboolean _test_auto() fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); test_mode++; } @@ -391,7 +422,7 @@ int main(int argc, char *argv[]) out: SAFE_G_FREE(g_path); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); return 0; } diff --git a/jpeg/unittest/libmm_jpeg_unittest.cpp b/jpeg/unittest/libmm_jpeg_unittest.cpp index 7c4474b..2e35028 100644 --- a/jpeg/unittest/libmm_jpeg_unittest.cpp +++ b/jpeg/unittest/libmm_jpeg_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_jpeg_unittest.h" #include "FileInterface.h" #include "mm_util_jpeg.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-jpeg-unittest.jpg") #define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "libmm-jpeg-result.jpg") @@ -41,27 +42,27 @@ class libmm_jpeg_Test : public ::testing::Test { TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; - ret = mm_util_decode_from_jpeg_file(NULL, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(NULL, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); } @@ -69,53 +70,53 @@ TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_memory_p) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); EXPECT_TRUE(err); - ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, + MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_jpeg_Test, mm_util_decode_from_jpeg_memory_n) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); EXPECT_TRUE(err); - ret = mm_util_decode_from_jpeg_memory(NULL, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_memory(NULL, IFile.readDataSize, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL); + ret = mm_util_decode_from_jpeg_memory(IFile.readData, IFile.readDataSize, + MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, NULL); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); } TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_jpeg_encode_to_file(&decode_image, 100, ENCODE_FILE_PATH); + ret = mm_util_jpeg_encode_to_file((mm_image_info_s *)decode_image, 100, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_n) @@ -133,68 +134,24 @@ TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_file_n) EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); } -TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_memory_p) -{ - int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; - void *buffer = NULL; - size_t size = 0; - - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); - EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); - - ret = mm_util_jpeg_encode_to_memory(&buffer, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100); - EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(buffer != NULL); - EXPECT_NE(size, 0); - - if (decode_image.data != NULL) - free(decode_image.data); -} - -TEST(libmm_jpeg_Test, mm_util_jpeg_encode_to_memory_n) -{ - int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; - void *buffer = NULL; - unsigned int size = 0; - - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); - EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); - - ret = mm_util_jpeg_encode_to_memory(NULL, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100); - EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - - ret = mm_util_jpeg_encode_to_memory(&buffer, NULL, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 100); - EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - - ret = mm_util_jpeg_encode_to_memory(&buffer, &size, (unsigned char*)decode_image.data, (unsigned int)decode_image.width, (unsigned int)decode_image.height, decode_image.color, 0); - EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); - - if (decode_image.data != NULL) - free(decode_image.data); -} - TEST(libmm_jpeg_Test, mm_util_encode_to_jpeg_memory_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image = {0, 0, MM_UTIL_COLOR_RGB24, NULL, 0, 0}; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; - ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); + ret = mm_util_decode_from_jpeg_file(DECODE_FILE_PATH, MM_UTIL_COLOR_RGB24, + MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_jpeg_memory(&decode_image, 100, &buffer, &size); + ret = mm_util_encode_to_jpeg_memory((mm_image_info_s *)decode_image, 100, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); if (buffer != NULL) free(buffer); diff --git a/png/include/mm_util_png.h b/png/include/mm_util_png.h index 7552300..6a10874 100755 --- a/png/include/mm_util_png.h +++ b/png/include/mm_util_png.h @@ -50,8 +50,8 @@ typedef enum { MM_UTIL_COMPRESSION_9 = 9 /* Best compression */ } mm_util_png_compression; -int mm_util_decode_from_png_file(const char *fpath, mm_image_info_s * decoded); -int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_image_info_s * decoded); +int mm_util_decode_from_png_file(const char *file_path, mm_util_image_h *decoded); +int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_util_image_h *decoded); int mm_util_encode_to_png_file(mm_image_info_s *decoded, mm_util_png_compression compression_level, const char *fpath); int mm_util_encode_to_png_memory(mm_image_info_s *decoded, mm_util_png_compression compression_level, void **data, size_t *size); diff --git a/png/mm_util_png.c b/png/mm_util_png.c index 40ceb52..d5fc22d 100755 --- a/png/mm_util_png.c +++ b/png/mm_util_png.c @@ -143,16 +143,20 @@ static void __get_property(png_property_s *png_prop, png_structp png_ptr, png_in } -static int _read_png(FILE *fp, void *memory, const size_t memory_size, mm_image_info_s *decoded) +static int __read_png(FILE *fp, void *memory, const size_t memory_size, mm_util_image_h *decoded) { + int ret = MM_UTIL_ERROR_NONE; png_structp png_ptr; png_infop info_ptr; guint row_index; png_mem_s png_mem_ptr = {memory, memory_size, 0}; png_property_s png_prop; + void *_data = NULL; mm_util_retvm_if(((fp == NULL) && (memory == NULL)), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid png image"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); + + mm_util_fenter(); /* create libpng structures to read png */ png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, (png_voidp) NULL, __user_error_fn, __user_warning_fn); @@ -200,9 +204,9 @@ static int _read_png(FILE *fp, void *memory, const size_t memory_size, mm_image_ mm_util_sec_debug("Decoding with libpng is done!"); - decoded->data = (void *)png_malloc(png_ptr, sizeof(png_bytep) * data_size); - if (decoded->data == NULL) { - mm_util_error("out of memory"); + _data = (void *)png_malloc(png_ptr, sizeof(png_bytep) * data_size); + if (!_data) { + mm_util_error("Failed to memory allocation"); png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); return MM_UTIL_ERROR_OUT_OF_MEMORY; @@ -210,7 +214,7 @@ static int _read_png(FILE *fp, void *memory, const size_t memory_size, mm_image_ /* read png data */ for (row_index = 0; row_index < png_prop.height; row_index++) { - memcpy(decoded->data + (row_index * rowbytes), row_pointers[row_index], rowbytes); + memcpy(_data + (row_index * rowbytes), row_pointers[row_index], rowbytes); png_free(png_ptr, row_pointers[row_index]); } @@ -219,14 +223,12 @@ static int _read_png(FILE *fp, void *memory, const size_t memory_size, mm_image_ png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); - /* set result */ - decoded->width = (unsigned long)png_prop.width; - decoded->height = (unsigned long)png_prop.height; - decoded->size = data_size; + ret = mm_image_create_image((unsigned int)png_prop.width, (unsigned int)png_prop.height, MM_UTIL_COLOR_RGBA, _data, data_size, decoded); + MMUTIL_SAFE_FREE(_data); - mm_util_debug("width (%u) height (%u) size (%zu)", decoded->width, decoded->height, decoded->size); + mm_util_fleave(); - return MM_UTIL_ERROR_NONE; + return ret; } int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_level, FILE *fp, void **buffer, size_t *size) @@ -311,51 +313,32 @@ int _write_png(mm_image_info_s *decoded, mm_util_png_compression compression_lev return MM_UTIL_ERROR_NONE; } -int mm_util_decode_from_png_file(const char *fpath, mm_image_info_s *decoded) +int mm_util_decode_from_png_file(const char *file_path, mm_util_image_h *decoded) { int ret = MM_UTIL_ERROR_NONE; FILE *fp = NULL; - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); - mm_util_retvm_if(!MMUTIL_STRING_VALID(fpath), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid path"); + mm_util_retvm_if(!MMUTIL_STRING_VALID(file_path), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid file_path"); + mm_util_retvm_if(!decoded, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid image handle"); - mm_util_fenter(); + mm_util_sec_debug("file_path [%s]", file_path); - ret = mm_util_safe_fopen(fpath, "r", &fp); - if (ret != MM_UTIL_ERROR_NONE) { - mm_util_error("mm_util_safe_fopen failed (%d)", ret); - mm_util_safe_fclose(fp); - mm_util_fleave(); - return ret; - } + ret = mm_util_safe_fopen(file_path, "r", &fp); + mm_util_retvm_if(ret != MM_UTIL_ERROR_NONE, ret, "fail to mm_util_safe_fopen [%d]", ret); - ret = _read_png(fp, NULL, 0, decoded); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_png failed (%d)", ret); + ret = __read_png(fp, NULL, 0, decoded); mm_util_safe_fclose(fp); - mm_util_fleave(); - return ret; } -int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_image_info_s *decoded) +int mm_util_decode_from_png_memory(void *memory, const size_t src_size, mm_util_image_h *decoded) { - int ret = MM_UTIL_ERROR_NONE; - - mm_util_retvm_if((memory == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid png image"); - mm_util_retvm_if((decoded == NULL), MM_UTIL_ERROR_INVALID_PARAMETER, "invalid color image"); + mm_util_retvm_if(!memory, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid png image"); + mm_util_retvm_if(!src_size, MM_UTIL_ERROR_INVALID_PARAMETER, "invalid src_size"); - mm_util_fenter(); - - ret = _read_png(NULL, memory, src_size, decoded); - if (ret != MM_UTIL_ERROR_NONE) - mm_util_error("_write_png failed (%d)", ret); - - mm_util_fleave(); - - return ret; + return __read_png(NULL, memory, src_size, decoded); } int mm_util_encode_to_png_file(mm_image_info_s *decoded, mm_util_png_compression compression_level, const char *fpath) diff --git a/png/test/CMakeLists.txt b/png/test/CMakeLists.txt old mode 100755 new mode 100644 index bac86ec..8e76d88 --- a/png/test/CMakeLists.txt +++ b/png/test/CMakeLists.txt @@ -14,5 +14,5 @@ FOREACH(src ${sources}) GET_FILENAME_COMPONENT(src_name ${src} NAME_WE) MESSAGE("${src_name}") ADD_EXECUTABLE(${src_name} ${src}) - TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) + TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS} mmutil_common) ENDFOREACH() diff --git a/png/test/mm_util_png_testsuite.c b/png/test/mm_util_png_testsuite.c index 44851d7..5ebc60c 100644 --- a/png/test/mm_util_png_testsuite.c +++ b/png/test/mm_util_png_testsuite.c @@ -26,10 +26,12 @@ #include #include #include +#include #include #define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } } #define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } } +#define SAFE_IMAGE_FREE(x) { if (x != NULL) { mm_image_destroy_image(x); x = NULL; } } #define DECODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_dec_file.raw") #define DECODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_dec_mem.raw") @@ -57,13 +59,15 @@ static char *MODE_TO_STR[] = { /* for arguments */ static int g_test_mode = 0; static char *g_path = NULL; +static unsigned int g_width = 0; +static unsigned int g_height = 0; static int g_compression = MM_UTIL_COMPRESSION_6; /* for reading file */ static void *g_readed_data = NULL; static size_t g_readed_size = 0; -static mm_image_info_s g_decoded_data = {0,}; +static mm_util_image_h g_decoded_data = NULL; static gboolean _read_file(char *path, void **data, size_t *length) { @@ -179,6 +183,8 @@ void _print_help(const char *argv0) gboolean _get_arguments(int argc, char *argv[]) { + int width = 0, height = 0; + if (FALSE == _get_input_data(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) { fprintf(stderr, "\t[PNG_testsuite] wrong mode(%s) for test\n", argv[1]); _print_help(argv[0]); @@ -197,7 +203,6 @@ gboolean _get_arguments(int argc, char *argv[]) } else if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) { /* do nothing */ } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) { - int width = 0, height = 0; if (argc < 4) { fprintf(stderr, "\t[PNG_testsuite] not enough args\n"); _print_help(argv[0]); @@ -207,12 +212,12 @@ gboolean _get_arguments(int argc, char *argv[]) fprintf(stderr, "\t[PNG_testsuite] wrong width %s\n", argv[3]); return FALSE; } - g_decoded_data.width = (unsigned long)width; + g_width = (unsigned int)width; if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &height)) { fprintf(stderr, "\t[PNG_testsuite] wrong height %s\n", argv[4]); return FALSE; } - g_decoded_data.height = (unsigned long)height; + g_height = (unsigned int)height; if (FALSE == _get_input_data(argv[5], MM_UTIL_COMPRESSION_1, MM_UTIL_COMPRESSION_9, &g_compression)) fprintf(stderr, "\t[PNG_testsuite] wrong compression_level %s\n", argv[5]); } else { @@ -226,6 +231,8 @@ gboolean _get_arguments(int argc, char *argv[]) gboolean _test_decode(const png_test_mode_e mode) { int ret = 0; + unsigned char *data = NULL; + size_t size = 0; /* test decoding png */ if (mode == TEST_DECODE_FILE) { @@ -234,10 +241,17 @@ gboolean _test_decode(const png_test_mode_e mode) fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_png_file failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_FILE_PATH, data, size)) { fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } else if (mode == TEST_DECODE_MEMORY) { if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[PNG_testsuite] reading file error\n"); @@ -249,10 +263,17 @@ gboolean _test_decode(const png_test_mode_e mode) fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_png_memory failed %d\n", ret); return FALSE; } - if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) { + ret = mm_image_get_image(g_decoded_data, &g_width, &g_height, NULL, &data, &size); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_image_get_image failed %d\n", ret); + return FALSE; + } + if (FALSE == _write_file(DECODE_MEM_PATH, data, size)) { fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH); + SAFE_FREE(data); return FALSE; } + SAFE_FREE(data); } return TRUE; @@ -268,20 +289,26 @@ gboolean _test_encode(const png_test_mode_e mode) if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY)) return TRUE; - if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_decoded_data.size)) { + if (FALSE == _read_file(g_path, &g_readed_data, &g_readed_size)) { fprintf(stderr, "\t[PNG_testsuite] reading file error\n"); return FALSE; } + ret = mm_image_create_image(g_width, g_height, MM_UTIL_COLOR_RGBA, (unsigned char *)g_readed_data, + g_readed_size, &g_decoded_data); + if (ret != MM_UTIL_ERROR_NONE) { + fprintf(stderr, "\t[PNG_testsuite] mm_image_create_image failed : %d\n", ret); + return FALSE; + } /* test encoding png */ if (mode == TEST_ENCODE_FILE) { - ret = mm_util_encode_to_png_file(&g_decoded_data, g_compression, ENCODE_FILE_PATH); + ret = mm_util_encode_to_png_file((mm_image_info_s *)g_decoded_data, g_compression, ENCODE_FILE_PATH); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[PNG_testsuite] mm_util_encode_to_png_file failed : %d\n", ret); return FALSE; } } else if (mode == TEST_ENCODE_MEMORY) { - ret = mm_util_encode_to_png_memory(&g_decoded_data, g_compression, &encoded_data, &encoded_size); + ret = mm_util_encode_to_png_memory((mm_image_info_s *)g_decoded_data, g_compression, &encoded_data, &encoded_size); if (ret != MM_UTIL_ERROR_NONE) { fprintf(stderr, "\t[PNG_testsuite] mm_util_encode_to_png_memory failed : %d\n", ret); SAFE_FREE(encoded_data); @@ -331,7 +358,7 @@ gboolean _test_auto() fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST SUCCESS\n", MODE_TO_STR[test_mode]); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); test_mode++; } @@ -376,7 +403,7 @@ int main(int argc, char *argv[]) out: SAFE_G_FREE(g_path); SAFE_FREE(g_readed_data); - SAFE_FREE(g_decoded_data.data); + SAFE_IMAGE_FREE(g_decoded_data); return 0; } diff --git a/png/unittest/libmm_png_unittest.cpp b/png/unittest/libmm_png_unittest.cpp index 6838a1c..e67e7ba 100644 --- a/png/unittest/libmm_png_unittest.cpp +++ b/png/unittest/libmm_png_unittest.cpp @@ -19,6 +19,7 @@ #include "libmm_png_unittest.h" #include "FileInterface.h" #include "mm_util_png.h" +#include "mm_util_image.h" #define DECODE_FILE_PATH tzplatform_mkpath(TZ_SYS_BIN, "libmm-png-unittest.png") #define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "libmm-png-result.png") @@ -41,22 +42,19 @@ class libmm_png_Test : public ::testing::Test { TEST(libmm_png_Test, mm_util_decode_from_png_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_png_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_png_Test, mm_util_decode_from_png_file_n) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_png_file(NULL, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_INVALID_PARAMETER); @@ -69,7 +67,7 @@ TEST(libmm_png_Test, mm_util_decode_from_png_memory_p) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -77,19 +75,16 @@ TEST(libmm_png_Test, mm_util_decode_from_png_memory_p) ret = mm_util_decode_from_png_memory(IFile.readData, IFile.readDataSize, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_EQ(decode_image.width, 640); - EXPECT_EQ(decode_image.height, 480); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_png_Test, mm_util_decode_from_png_memory_n) { int ret = MM_UTIL_ERROR_NONE; gboolean err = TRUE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; FileInterface IFile = FileInterface(DECODE_FILE_PATH); err = IFile.ReadData(); @@ -105,17 +100,16 @@ TEST(libmm_png_Test, mm_util_decode_from_png_memory_n) TEST(libmm_png_Test, mm_util_encode_to_png_file_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; ret = mm_util_decode_from_png_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_png_file(&decode_image, MM_UTIL_COMPRESSION_6, ENCODE_FILE_PATH); + ret = mm_util_encode_to_png_file((mm_image_info_s *)decode_image, MM_UTIL_COMPRESSION_6, ENCODE_FILE_PATH); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); } TEST(libmm_png_Test, mm_util_encode_to_png_file_n) @@ -133,21 +127,20 @@ TEST(libmm_png_Test, mm_util_encode_to_png_file_n) TEST(libmm_png_Test, mm_util_encode_to_png_memory_p) { int ret = MM_UTIL_ERROR_NONE; - mm_image_info_s decode_image; + mm_util_image_h decode_image = NULL; void *buffer = NULL; size_t size = 0; ret = mm_util_decode_from_png_file(DECODE_FILE_PATH, &decode_image); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); - EXPECT_TRUE(decode_image.data != NULL); + EXPECT_TRUE(mm_image_is_valid_image(decode_image)); - ret = mm_util_encode_to_png_memory(&decode_image, MM_UTIL_COMPRESSION_6, &buffer, &size); + ret = mm_util_encode_to_png_memory((mm_image_info_s *)decode_image, MM_UTIL_COMPRESSION_6, &buffer, &size); EXPECT_EQ(ret, MM_UTIL_ERROR_NONE); EXPECT_TRUE(buffer != NULL); EXPECT_NE(size, 0); - if (decode_image.data != NULL) - free(decode_image.data); + mm_image_destroy_image(decode_image); if (buffer != NULL) free(buffer); -- 2.7.4