#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);
}
/* 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,
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;
}
}
}
- 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;
}
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)
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()
#include <glib.h>
#include <limits.h>
#include <mm_util_bmp.h>
+#include <mm_util_image.h>
#include <tzplatform_config.h>
#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")
/* 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)
{
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;
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) {
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");
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;
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);
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++;
}
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;
}
#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")
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);
{
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();
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();
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)
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);
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}
)
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)
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);
#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;
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;
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;
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;
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])
}
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)
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)
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()
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <glib.h>
#include <limits.h>
#include <mm_util_gif.h>
+#include <mm_util_image.h>
#include <tzplatform_config.h>
-#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;
}
#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")
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);
{
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();
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();
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)
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);
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()
#include <string.h>
#include <mm_util_jpeg.h>
+#include <mm_util_image.h>
#include <mm_util_imgcv.h>
#define MAX_FILENAME_LEN 1024
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");
}
/* 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;
/* 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;
#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")
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)
#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")
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);
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)
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);
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);
}
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);
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)
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);
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);
}
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);
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)
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);
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);
}
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);
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)
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);
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);
}
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
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);
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);
/* 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);
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];
/* 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");
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)
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)) {
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);
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)) {
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;
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()
#include <glib.h>
#include <limits.h>
#include <mm_util_jpeg.h>
+#include <mm_util_image.h>
#include <tzplatform_config.h>
#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")
/* 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;
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)
{
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]);
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))
_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;
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]);
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");
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;
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);
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++;
}
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;
}
#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")
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);
}
{
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)
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);
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);
}
-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);
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;
/* 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]);
}
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)
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)
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()
#include <glib.h>
#include <limits.h>
#include <mm_util_png.h>
+#include <mm_util_image.h>
#include <tzplatform_config.h>
#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")
/* 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)
{
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]);
} 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]);
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 {
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) {
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");
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;
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);
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++;
}
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;
}
#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")
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);
{
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();
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();
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)
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);
projects / platform / core / multimedia / libmm-utility.git / commitdiff