#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include <sys/stat.h>
+#include <errno.h>
+#include <glib.h>
+#include <limits.h>
#include <mm_util_bmp.h>
#include <tzplatform_config.h>
-#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.")
-#define BUFFER_SIZE 128
+#define SAFE_FREE(x) { if (x != NULL) { free(x); x = NULL; } }
+#define SAFE_G_FREE(x) { if (x != NULL) { g_free(x); x = NULL; } }
-static inline void flush_stdin()
+#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")
+#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_enc_file.jpg")
+#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "bmp_test_enc_mem.jpg")
+
+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",
+ "",
+};
+
+/* for arguments */
+static int g_test_mode = 0;
+static char *g_path = NULL;
+
+/* for reading file */
+static void *g_readed_data = NULL;
+static size_t g_readed_size = 0;
+
+static mm_util_bmp_data g_decoded_data = {0,};
+
+static gboolean _read_file(char *path, void **data, size_t *length)
{
- int ch;
- while ((ch = getchar()) != EOF && ch != '\n') ;
+ FILE *fp = NULL;
+ long len = 0;
+
+ if (!path || !data || length == 0) {
+ fprintf(stderr, "\t[BMP_testsuite] invalid data %s %p %p\n", path, data, length);
+ return FALSE;
+ }
+
+ fprintf(stderr, "\t[BMP_testsuite] %s read\n", path);
+
+ fp = fopen(path, "r");
+ if (fp == NULL) {
+ fprintf(stderr, "\t[BMP_testsuite] fopen failed (%d) \n", errno);
+ return FALSE;
+ }
+
+ fseek(fp, 0, SEEK_END);
+ len = ftell(fp);
+ if (len < 0) {
+ fprintf(stderr, "\t[BMP_testsuite] ftell failed \n");
+ fclose(fp);
+ return FALSE;
+ }
+
+ rewind(fp);
+ *data = (void *)calloc(1, len);
+ if (*data == NULL) {
+ fprintf(stderr, "\tmemory allocation failed \n");
+ fclose(fp);
+ return FALSE;
+ }
+
+ *length = fread(*data, 1, (size_t)len, fp);
+ if (*length != len) {
+ fprintf(stderr, "\t[BMP_testsuite] fread failed \n");
+ }
+
+ fclose(fp);
+
+ if (*data == NULL) {
+ *length = 0;
+ return FALSE;
+ }
+
+ *length = (size_t)len;
+
+ fprintf(stderr, "\t[BMP_testsuite] %s %zu read DONE\n", path, *length);
+
+ return TRUE;
}
-int main(int argc, char *argv[])
+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[BMP_testsuite] invalid data %s %p %zu\n", path, data, length);
+ return FALSE;
+ }
+
+ fprintf(stderr, "\t[BMP_testsuite] %s %p %zu write\n", path, data, length);
+
+ fp = fopen(path, "w");
+ if (fp == NULL) {
+ fprintf(stderr, "\t[BMP_testsuite] fopen failed (%d) \n", errno);
+ return FALSE;
+ }
+
+ len = fwrite(data, 1, length, fp);
+ if (len != length) {
+ fprintf(stderr, "\t[BMP_testsuite] fwrite failed \n");
+ }
+
+ fclose(fp);
+ fp = NULL;
+
+ fprintf(stderr, "\t[BMP_testsuite] %s write DONE\n", path);
+
+ return TRUE;
+}
+
+gboolean _get_input_data(const char *argv, const long min, const long max, int *data)
+{
+ 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;
+}
+
+void _print_help(const char *argv0)
+{
+ 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");
+}
+
+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[BMP_testsuite] wrong mode(%s) for test\n", argv[1]);
+ _print_help(argv[0]);
+ return FALSE;
+ }
+
+ g_path = g_strdup(argv[2]);
+ if (g_path == NULL) {
+ fprintf(stderr, "\t[BMP_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[BMP_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[BMP_testsuite] wrong width %s\n", argv[3]);
+ return FALSE;
+ }
+ g_decoded_data.width = (unsigned long)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;
+ } else {
+ fprintf(stderr, "\t[BMP_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;
+
+ /* test decoding jpeg */
+ if (mode == TEST_DECODE_FILE) {
+ ret = mm_util_decode_from_bmp_file(&g_decoded_data, g_path);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ 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)) {
+ fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH);
+ return FALSE;
+ }
+ } 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");
+ return FALSE;
+ }
+
+ ret = mm_util_decode_from_bmp_memory(&g_decoded_data, g_readed_data, (unsigned int)g_readed_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ 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)) {
+ fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+gboolean _test_encode(const bmp_test_mode_e mode)
{
int ret = 0;
- mm_util_bmp_data decoded;
+ /* for encoding jpeg to memory */
+ void *encoded_data = NULL;
+ unsigned int encoded_size = 0;
+
+ if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY))
+ return TRUE;
+
+ if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_readed_size)) {
+ fprintf(stderr, "\t[BMP_testsuite] reading file error\n");
+ return FALSE;
+ }
+ g_decoded_data.size = (unsigned int)g_readed_size;
+
+ /* test encoding jpeg */
+ if (mode == TEST_ENCODE_FILE) {
+ ret = mm_util_encode_bmp_to_file(&g_decoded_data, ENCODE_FILE_PATH);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[BMP_testsuite] mm_util_jpeg_encode_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);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[BMP_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret);
+ SAFE_FREE(encoded_data);
+ return FALSE;
+ }
+ if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) {
+ fprintf(stderr, "\t[BMP_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH);
+ SAFE_FREE(encoded_data);
+ return FALSE;
+ }
+ }
+ SAFE_FREE(encoded_data);
+ return TRUE;
+}
+
+gboolean _test_auto()
+{
+ bmp_test_mode_e test_mode = TEST_DECODE_FILE;
+
+ while (test_mode < TEST_NUM) {
+ fprintf(stderr, "\t[BMP_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[BMP_testsuite] Not enough memory\n");
+ return FALSE;
+ }
+ }
+ /* test decoding jpeg */
+ if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(test_mode)) {
+ fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
+ }
+ }
+
+ /* test encoding jpeg */
+ if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(test_mode)) {
+ fprintf(stderr, "\t[BMP_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
+ }
+ }
+
+ 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);
+ test_mode++;
+ }
+
+ return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
if (argc < 2) {
- fprintf(stderr, "\t[usage]\n");
- fprintf(stderr, "\t\t1. decode : mm_util_bmp_testsuite decode filepath.bmp\n");
+ _print_help(argv[0]);
return 0;
}
- if (!strcmp("decode", argv[1])) {
- ret = mm_util_decode_from_bmp_file(&decoded, argv[2]);
- } else {
- fprintf(stderr, "\tunknown command [%s]\n", argv[1]);
- return 0;
+ if (FALSE == _get_arguments(argc, argv)) {
+ fprintf(stderr, "\t[BMP_testsuite] _get_arguments failed\n");
+ goto out;
}
- if (ret != MM_UTIL_ERROR_NONE) {
- fprintf(stderr, "\tERROR is occurred %x\n", ret);
- } else {
- fprintf(stderr, "\tBMP OPERATION SUCCESS\n");
- {
- if (decoded.data) {
- fprintf(stderr, "\t##Decoded data##: %p\t width: %lu\t height:%lu\t size: %llu\n", decoded.data, decoded.width, decoded.height, decoded.size);
- char filename[BUFFER_SIZE] = { 0, };
- memset(filename, 0, BUFFER_SIZE);
- {
- snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "bmp");
- }
-
- ret = mm_util_encode_bmp_to_file(&decoded, filename);
-
- free(decoded.data);
- } else {
- fprintf(stderr, "\tDECODED data is NULL\n");
- }
+ /* test full functions automatically */
+ if (g_test_mode == TEST_AUTO) {
+ if (FALSE == _test_auto())
+ fprintf(stderr, "\t[BMP_testsuite] _test_auto failed\n");
+ goto out;
+ }
+
+ /* test decoding jpeg */
+ if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(g_test_mode)) {
+ fprintf(stderr, "\t[BMP_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]);
+ goto out;
+ }
+ }
+
+ /* test encoding jpeg */
+ if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(g_test_mode)) {
+ fprintf(stderr, "\t[BMP_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_FREE(g_decoded_data.data);
+
return 0;
}
* limitations under the License.
*
*/
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <glib.h>
+#include <limits.h>
#include <mm_util_jpeg.h>
#include <tzplatform_config.h>
-#define ENCODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "encode_test.jpg")
-#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.")
-
-#define TRUE 1
-#define FALSE 0
-#define BUFFER_SIZE 128
-static inline void flush_stdin()
-{
- int ch;
- while ((ch = getchar()) != EOF && ch != '\n');
-}
-
-
-static int _read_file(char *file_name, void **data, unsigned int *data_size)
+#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 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")
+#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_enc_file.jpg")
+#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "jpeg_test_enc_mem.jpg")
+
+typedef enum {
+ TEST_AUTO,
+ TEST_DECODE_FILE,
+ TEST_DECODE_MEMORY,
+ TEST_ENCODE_FILE,
+ TEST_ENCODE_MEMORY,
+ TEST_NUM,
+} jpeg_test_mode_e;
+
+static char *MODE_TO_STR[] = {
+ "AUTO",
+ "DECODE_FILE",
+ "DECODE_MEMORY",
+ "ENCODE_FILE",
+ "ENCODE_MEMORY",
+ "",
+};
+
+/* for arguments */
+static int g_test_mode = 0;
+static char *g_path = NULL;
+static int g_color = MM_UTIL_COLOR_RGB24;
+static int g_quality = 75;
+static int g_downscale = MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1;
+
+/* for reading file */
+static void *g_readed_data = NULL;
+static size_t g_readed_size = 0;
+
+static mm_util_jpeg_yuv_data g_decoded_data = {0,};
+
+static gboolean _read_file(char *path, void **data, size_t *length)
{
FILE *fp = NULL;
- long file_size = 0;
+ long len = 0;
- if (!file_name || !data || !data_size) {
- fprintf(stderr, "\tNULL pointer\n");
+ if (!path || !data || length == 0) {
+ fprintf(stderr, "\t[JPEG_testsuite] invalid data %s %p %p\n", path, data, length);
return FALSE;
}
- fprintf(stderr, "\tTry to open %s to read\n", file_name);
+ fprintf(stderr, "\t[JPEG_testsuite] %s read\n", path);
- fp = fopen(file_name, "r");
+ fp = fopen(path, "r");
if (fp == NULL) {
- fprintf(stderr, "\tfile open failed %d\n", errno);
+ fprintf(stderr, "\t[JPEG_testsuite] fopen failed (%d) \n", errno);
return FALSE;
}
fseek(fp, 0, SEEK_END);
- file_size = ftell(fp);
- if (file_size > -1L) {
- rewind(fp);
- *data = (void *)calloc(1, file_size);
- if (*data == NULL) {
- fprintf(stderr, "\tmemory allocation failed %d\n", errno);
- fclose(fp);
- fp = NULL;
- return FALSE;
- } else {
- if (fread(*data, 1, file_size, fp) == (size_t)file_size) {
- fprintf(stderr, "#Success# fread\n");
- } else {
- fprintf(stderr, "#Error# fread\n");
- fclose(fp);
- fp = NULL;
- return FALSE;
- }
- }
+ len = ftell(fp);
+ if (len < 0) {
+ fprintf(stderr, "\t[JPEG_testsuite] ftell failed \n");
fclose(fp);
- fp = NULL;
+ return FALSE;
+ }
- if (*data) {
- *data_size = (unsigned int)file_size;
- return TRUE;
- } else {
- *data_size = 0;
- return FALSE;
- }
- } else {
- fprintf(stderr, "#Error# ftell\n");
+ rewind(fp);
+ *data = (void *)calloc(1, len);
+ if (*data == NULL) {
+ fprintf(stderr, "\tmemory allocation failed \n");
fclose(fp);
- fp = NULL;
return FALSE;
}
-}
+ *length = fread(*data, 1, (size_t)len, fp);
+ if (*length != len) {
+ fprintf(stderr, "\t[JPEG_testsuite] fread failed \n");
+ }
+
+ fclose(fp);
+
+ if (*data == NULL) {
+ *length = 0;
+ return FALSE;
+ }
+
+ *length = (size_t)len;
+
+ fprintf(stderr, "\t[JPEG_testsuite] %s %zu read DONE\n", path, *length);
-static int _write_file(const char *file_name, void *data, unsigned int data_size)
+ return TRUE;
+}
+
+static gboolean _write_file(const char *path, void *data, size_t length)
{
FILE *fp = NULL;
+ size_t len = 0;
- if (!file_name || !data || data_size == 0) {
- fprintf(stderr, "\tinvalid data %s %p size:%u\n", file_name, data, data_size);
+ if (!path || !data || length == 0) {
+ fprintf(stderr, "\t[JPEG_testsuite] invalid data %s %p %zu\n", path, data, length);
return FALSE;
}
- fprintf(stderr, "\tTry to open %s to write\n", file_name);
+ fprintf(stderr, "\t[JPEG_testsuite] %s %p %zu write\n", path, data, length);
- fp = fopen(file_name, "w");
+ fp = fopen(path, "w");
if (fp == NULL) {
- fprintf(stderr, "\tfile open failed %d\n", errno);
+ fprintf(stderr, "\t[JPEG_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[JPEG_testsuite] fwrite failed \n");
+ }
+
fclose(fp);
fp = NULL;
- fprintf(stderr, "\tfile [%s] write DONE\n", file_name);
+ fprintf(stderr, "\t[JPEG_testsuite] %s write DONE\n", path);
return TRUE;
}
+gboolean _get_input_data(const char *argv, const long min, const long max, int *data)
+{
+ if (argv == NULL || strlen(argv) == 0)
+ return FALSE;
-int main(int argc, char *argv[])
+ long temp = g_ascii_strtoll(argv, NULL, 10);
+ if (temp < min || temp > max)
+ return FALSE;
+
+ *data = (int)temp;
+
+ return TRUE;
+}
+
+void _print_help(const char *argv0)
{
- int ret = 0;
- unsigned int src_size = 0;
- unsigned int dst_size = 0;
- int width = 0;
- int height = 0;
- int quality = 0;
- void *src = NULL;
- void *dst = NULL;
-
- mm_util_jpeg_yuv_data decoded_data = {0,};
- mm_util_color_format_e fmt; /* = MM_UTIL_COLOR_RGB24; */
- mm_util_jpeg_decode_downscale downscale;
+ fprintf(stderr, "\t[usage]\n");
+ fprintf(stderr, "\t\t1. decode & encode : %s mode path color_format(opt.) quality(opt.) downscale(opt.)\n", argv0);
+ fprintf(stderr, "\t\t2. decode : %s mode path color_format(opt.)\n", argv0);
+ fprintf(stderr, "\t\t3. encode : %s mode path width(mand.) height(mand.) color_format(mand.) quality(opt.) downscale(opt.)\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. encode : mm_util_jpeg_testsuite encode filepath.yuv width height quality\n");
- fprintf(stderr, "\t\t2. decode : mm_util_jpeg_testsuite decode filepath.jpg\n");
- fprintf(stderr, "\t\t3. decode_ds : mm_util_jpeg_testsuite decode_ds filepath.jpg format downscale\n");
- return 0;
+gboolean _get_arguments(int argc, char *argv[])
+{
+ 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]);
+ return FALSE;
}
- /*g_type_init(); //when you include WINK */
+ g_path = g_strdup(argv[2]);
+ if (g_path == NULL) {
+ fprintf(stderr, "\t[JPEG_testsuite] Not enough memory\n");
+ return FALSE;
+ }
+ if (g_test_mode == TEST_AUTO) {
+ if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color))
+ 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))
+ 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))
+ fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color);
+ } else if (g_test_mode == TEST_DECODE_MEMORY) {
+ if (FALSE == _get_input_data(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color))
+ fprintf(stderr, "\t[JPEG_testsuite] color is default(%d)\n", g_color);
+ } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_MEMORY) {
+ if (argc < 5) {
+ fprintf(stderr, "\t[JPEG_testsuite] not enough args\n");
+ _print_help(argv[0]);
+ return FALSE;
+ }
+ if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &g_decoded_data.width)) {
+ fprintf(stderr, "\t[JPEG_testsuite] wrong width %s\n", argv[3]);
+ return FALSE;
+ }
+ if (FALSE == _get_input_data(argv[4], 0, INT_MAX, &g_decoded_data.height)) {
+ fprintf(stderr, "\t[JPEG_testsuite] wrong height %s\n", argv[4]);
+ return FALSE;
+ }
+ 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 (!strcmp("encode", argv[1])) {
- if (_read_file(argv[2], &src, &src_size)) {
- width = atoi(argv[3]);
- height = atoi(argv[4]);
- quality = atoi(argv[5]);
- fmt = atoi(argv[6]);
+ if (FALSE == _get_input_data(argv[7], MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1, MM_UTIL_JPEG_DECODE_DOWNSCALE_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]);
+ return FALSE;
+ }
- ret = mm_util_jpeg_encode_to_memory(&dst, &dst_size, src, width, height, fmt, quality);
- } else {
- ret = MM_UTIL_ERROR_INVALID_OPERATION;
- }
- } else if (!strcmp("enc2file", argv[1])) {
- if (_read_file(argv[2], &src, &src_size)) {
- width = atoi(argv[3]);
- height = atoi(argv[4]);
- quality = atoi(argv[5]);
- fmt = atoi(argv[6]);
+ return TRUE;
+}
- ret = mm_util_jpeg_encode_to_file(ENCODE_RESULT_PATH, src, width, height, fmt, quality);
- } else {
- ret = MM_UTIL_ERROR_INVALID_OPERATION;
+gboolean _test_decode(const jpeg_test_mode_e mode)
+{
+ int ret = 0;
+
+ /* test decoding jpeg */
+ if (mode == TEST_DECODE_FILE) {
+ ret = mm_util_decode_from_jpeg_file_with_downscale(&g_decoded_data, g_path, g_color, g_downscale);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_file_with_downscale failed %d\n", ret);
+ return FALSE;
+ }
+ if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) {
+ fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH);
+ return FALSE;
+ }
+ } 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");
+ return FALSE;
}
- } else if (!strcmp("decode", argv[1])) {
- if (_read_file(argv[2], &src, &src_size)) {
- fmt = atoi(argv[3]);
- ret = mm_util_decode_from_jpeg_memory_with_downscale(&decoded_data, src, src_size, fmt, MM_UTIL_JPEG_DECODE_DOWNSCALE_1_1);
- free(src);
- src = NULL;
- } else {
- ret = MM_UTIL_ERROR_INVALID_OPERATION;
+ ret = mm_util_decode_from_jpeg_memory_with_downscale(&g_decoded_data, g_readed_data, (unsigned int)g_readed_size, g_color, g_downscale);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[JPEG_testsuite] mm_util_decode_from_jpeg_memory_with_downscale failed %d\n", ret);
+ return FALSE;
}
- } else if (!strcmp("decode_ds", argv[1])) {
- if (_read_file(argv[2], &src, &src_size)) {
- fmt = atoi(argv[3]);
- downscale = atoi(argv[4]);
- ret = mm_util_decode_from_jpeg_memory_with_downscale(&decoded_data, src, src_size, fmt, downscale);
+ if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) {
+ fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+gboolean _test_encode(const jpeg_test_mode_e mode)
+{
+ int ret = 0;
+ /* for encoding jpeg to memory */
+ void *encoded_data = NULL;
+ unsigned int encoded_size = 0;
- free(src);
- src = NULL;
- } else {
- ret = MM_UTIL_ERROR_INVALID_OPERATION;
+ if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_MEMORY))
+ return TRUE;
+
+ if (FALSE == _read_file(g_path, &g_decoded_data.data, &g_readed_size)) {
+ fprintf(stderr, "\t[JPEG_testsuite] reading file error\n");
+ return FALSE;
+ }
+ g_decoded_data.size = (unsigned int)g_readed_size;
+ g_decoded_data.format = (mm_util_color_format_e)g_color;
+
+ /* test encoding jpeg */
+ if (mode == TEST_ENCODE_FILE) {
+ ret = mm_util_jpeg_encode_to_file(ENCODE_FILE_PATH, g_decoded_data.data, g_decoded_data.width, g_decoded_data.height, g_decoded_data.format, g_quality);
+ 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_jpeg_encode_to_memory(&encoded_data, &encoded_size, g_decoded_data.data, g_decoded_data.width, g_decoded_data.height, g_decoded_data.format, g_quality);
+ 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);
+ return FALSE;
+ }
+ if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) {
+ fprintf(stderr, "\t[JPEG_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH);
+ SAFE_FREE(encoded_data);
+ return FALSE;
}
- } else {
- fprintf(stderr, "\tunknown command [%s]\n", argv[1]);
- return 0;
}
- if (ret != MM_UTIL_ERROR_NONE) {
- fprintf(stderr, "\tERROR is occurred %x\n", ret);
- } else {
- fprintf(stderr, "\tJPEG OPERATION SUCCESS\n");
- if (!strcmp("encode", argv[1])) {
- if (dst) {
- fprintf(stderr, "\t##Encoded data##: %p\tsize: %u\n", dst, dst_size);
-
- _write_file(ENCODE_RESULT_PATH, dst, dst_size);
-
- free(dst);
- dst = NULL;
- dst_size = 0;
- } else {
- fprintf(stderr, "\tENCODED data is NULL\n");
+ SAFE_FREE(encoded_data);
+ return TRUE;
+}
+
+gboolean _test_auto()
+{
+ jpeg_test_mode_e test_mode = TEST_DECODE_FILE;
+
+ while (test_mode < TEST_NUM) {
+ fprintf(stderr, "\t[JPEG_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[JPEG_testsuite] Not enough memory\n");
+ return FALSE;
}
- } else {
- if (decoded_data.data) {
- fprintf(stderr, "\t##Decoded data##: %p\t width: %d\t height:%d\t size: %d\n", decoded_data.data, decoded_data.width, decoded_data.height, decoded_data.size);
- char filename[BUFFER_SIZE] = {0, };
- memset(filename, 0, BUFFER_SIZE);
- if (fmt == MM_UTIL_COLOR_RGB24 || fmt == MM_UTIL_COLOR_RGBA || fmt == MM_UTIL_COLOR_BGRA || fmt == MM_UTIL_COLOR_ARGB) {
- snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "rgb");
- } else if ((fmt == MM_UTIL_COLOR_YUV420) ||
- (fmt == MM_UTIL_COLOR_YUV422) ||
- (fmt == MM_UTIL_COLOR_NV12) ||
- (fmt == MM_UTIL_COLOR_NV21) ||
- (fmt == MM_UTIL_COLOR_NV16) ||
- (fmt == MM_UTIL_COLOR_NV61)) {
- snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "yuv");
- }
- _write_file(filename, decoded_data.data, decoded_data.size);
-
- free(decoded_data.data);
- decoded_data.data = NULL;
- decoded_data.size = 0;
- } else {
- fprintf(stderr, "\tDECODED data is NULL\n");
+ }
+ /* test decoding jpeg */
+ if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(test_mode)) {
+ fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
}
}
+
+ /* test encoding jpeg */
+ if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(test_mode)) {
+ fprintf(stderr, "\t[JPEG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
+ }
+ }
+
+ 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);
+ test_mode++;
+ }
+
+ return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
+ if (argc < 2) {
+ _print_help(argv[0]);
+ return 0;
+ }
+
+ if (FALSE == _get_arguments(argc, argv)) {
+ fprintf(stderr, "\t[JPEG_testsuite] _get_arguments failed\n");
+ goto out;
+ }
+
+ /* test full functions automatically */
+ if (g_test_mode == TEST_AUTO) {
+ if (FALSE == _test_auto())
+ fprintf(stderr, "\t[JPEG_testsuite] _test_auto failed\n");
+ goto out;
+ }
+
+ /* test decoding jpeg */
+ if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(g_test_mode)) {
+ fprintf(stderr, "\t[JPEG_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]);
+ goto out;
+ }
+ }
+
+ /* test encoding jpeg */
+ if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(g_test_mode)) {
+ fprintf(stderr, "\t[JPEG_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_FREE(g_decoded_data.data);
return 0;
}
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <glib.h>
+#include <limits.h>
#include <mm_util_png.h>
#include <tzplatform_config.h>
-#define DECODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "decode_test.")
+#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 TRUE 1
-#define FALSE 0
-#define BUFFER_SIZE 128
+#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")
+#define ENCODE_FILE_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_enc_file.jpg")
+#define ENCODE_MEM_PATH tzplatform_mkpath(TZ_USER_CONTENT, "png_test_enc_mem.jpg")
-static inline void flush_stdin()
-{
- int ch;
- while ((ch = getchar()) != EOF && ch != '\n') ;
-}
+typedef enum {
+ TEST_AUTO,
+ TEST_DECODE_FILE,
+ TEST_DECODE_MEMORY,
+ TEST_ENCODE_FILE,
+ TEST_ENCODE_MEMORY,
+ TEST_NUM,
+} png_test_mode_e;
+
+static char *MODE_TO_STR[] = {
+ "AUTO",
+ "DECODE_FILE",
+ "DECODE_MEMORY",
+ "ENCODE_FILE",
+ "ENCODE_MEMORY",
+ "",
+};
+
+/* for arguments */
+static int g_test_mode = 0;
+static char *g_path = NULL;
+static int g_compression = MM_UTIL_COMPRESSION_6;
-static int _read_file(char *file_name, void **data, int *data_size)
+/* for reading file */
+static void *g_readed_data = NULL;
+static size_t g_readed_size = 0;
+
+static mm_util_png_data g_decoded_data = {0,};
+
+static gboolean _read_file(char *path, void **data, size_t *length)
{
FILE *fp = NULL;
- long file_size = 0;
+ long len = 0;
- if (!file_name || !data || !data_size) {
- fprintf(stderr, "\tNULL pointer\n");
+ if (!path || !data || length == 0) {
+ fprintf(stderr, "\t[PNG_testsuite] invalid data %s %p %p\n", path, data, length);
return FALSE;
}
- fprintf(stderr, "\tTry to open %s to read\n", file_name);
+ fprintf(stderr, "\t[PNG_testsuite] %s read\n", path);
- fp = fopen(file_name, "r");
+ fp = fopen(path, "r");
if (fp == NULL) {
- fprintf(stderr, "\tfile open failed %d\n", errno);
+ fprintf(stderr, "\t[PNG_testsuite] fopen failed (%d) \n", errno);
return FALSE;
}
fseek(fp, 0, SEEK_END);
- file_size = ftell(fp);
- if (file_size > -1L) {
- rewind(fp);
- *data = (void *)calloc(1, file_size);
- if (*data == NULL) {
- fprintf(stderr, "\tmemory allocation failed %d\n", errno);
- fclose(fp);
- fp = NULL;
- return FALSE;
- } else {
- if (fread(*data, 1, file_size, fp) == (size_t)file_size) {
- fprintf(stderr, "\t#Success# fread\n");
- } else {
- fprintf(stderr, "\t#Error# fread\n");
- fclose(fp);
- fp = NULL;
- return FALSE;
- }
- }
+ len = ftell(fp);
+ if (len < 0) {
+ fprintf(stderr, "\t[PNG_testsuite] ftell failed \n");
fclose(fp);
- fp = NULL;
+ return FALSE;
+ }
- if (*data) {
- *data_size = file_size;
- return TRUE;
- } else {
- *data_size = 0;
- return FALSE;
- }
- } else {
- fprintf(stderr, "\t#Success# ftell\n");
+ rewind(fp);
+ *data = (void *)calloc(1, len);
+ if (*data == NULL) {
+ fprintf(stderr, "\tmemory allocation failed \n");
fclose(fp);
- fp = NULL;
return FALSE;
}
+
+ *length = fread(*data, 1, (size_t)len, fp);
+ if (*length != len) {
+ fprintf(stderr, "\t[PNG_testsuite] fread failed \n");
+ }
+
+ fclose(fp);
+
+ if (*data == NULL) {
+ *length = 0;
+ return FALSE;
+ }
+
+ *length = (size_t)len;
+
+ fprintf(stderr, "\t[PNG_testsuite] %s %zu read DONE\n", path, *length);
+
+ return TRUE;
}
-static int _write_file(const char *file_name, void *data, int data_size)
+static gboolean _write_file(const char *path, void *data, size_t length)
{
FILE *fp = NULL;
+ size_t len = 0;
- if (!file_name || !data || data_size <= 0) {
- fprintf(stderr, "\tinvalid data %s %p size:%d\n", file_name, data, data_size);
+ if (!path || !data || length == 0) {
+ fprintf(stderr, "\t[PNG_testsuite] invalid data %s %p %zu\n", path, data, length);
return FALSE;
}
- fprintf(stderr, "\tTry to open %s to write\n", file_name);
+ fprintf(stderr, "\t[PNG_testsuite] %s %p %zu write\n", path, data, length);
- fp = fopen(file_name, "w");
+ fp = fopen(path, "w");
if (fp == NULL) {
- fprintf(stderr, "\tfile open failed %d\n", errno);
+ fprintf(stderr, "\t[PNG_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[PNG_testsuite] fwrite failed \n");
+ }
+
fclose(fp);
fp = NULL;
- fprintf(stderr, "\tfile [%s] write DONE\n", file_name);
+ fprintf(stderr, "\t[PNG_testsuite] %s write DONE\n", path);
return TRUE;
}
-int main(int argc, char *argv[])
+gboolean _get_input_data(const char *argv, const long min, const long max, int *data)
+{
+ 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;
+}
+
+void _print_help(const char *argv0)
+{
+ fprintf(stderr, "\t[usage]\n");
+ fprintf(stderr, "\t\t1. decode & encode : %s mode path compression_level(opt.)\n", argv0);
+ fprintf(stderr, "\t\t2. decode : %s mode path\n", argv0);
+ fprintf(stderr, "\t\t3. encode : %s mode path width(mand.) height(mand.) compression_level(opt.)\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");
+}
+
+gboolean _get_arguments(int argc, char *argv[])
+{
+ 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]);
+ return FALSE;
+ }
+
+ g_path = g_strdup(argv[2]);
+ if (g_path == NULL) {
+ fprintf(stderr, "\t[PNG_testsuite] Not enough memory\n");
+ return FALSE;
+ }
+
+ if (g_test_mode == TEST_AUTO) {
+ if (FALSE == _get_input_data(argv[3], MM_UTIL_COMPRESSION_1, MM_UTIL_COMPRESSION_9, &g_compression))
+ fprintf(stderr, "\t[PNG_testsuite] compression_level is default(%d)\n", g_compression);
+ } 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]);
+ return FALSE;
+ }
+ if (FALSE == _get_input_data(argv[3], 0, INT_MAX, &width)) {
+ fprintf(stderr, "\t[PNG_testsuite] wrong width %s\n", argv[3]);
+ return FALSE;
+ }
+ g_decoded_data.width = (unsigned long)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;
+ 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 {
+ fprintf(stderr, "\t[PNG_testsuite] wrong mode for test %s\n", argv[1]);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean _test_decode(const png_test_mode_e mode)
{
int ret = 0;
- mm_util_png_data decoded_data;
- void *src = NULL;
- int src_size = 0;
- mm_util_png_compression compression = MM_UTIL_COMPRESSION_6; /* default */
+ /* test decoding jpeg */
+ if (mode == TEST_DECODE_FILE) {
+ ret = mm_util_decode_from_png_file(&g_decoded_data, g_path);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_jpeg_file_with_downscale failed %d\n", ret);
+ return FALSE;
+ }
+ if (FALSE == _write_file(DECODE_FILE_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) {
+ fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_FILE_PATH);
+ return FALSE;
+ }
+ } 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");
+ return FALSE;
+ }
+
+ ret = mm_util_decode_from_png_memory(&g_decoded_data, g_readed_data, (unsigned long long)g_readed_size);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[PNG_testsuite] mm_util_decode_from_jpeg_memory_with_downscale failed %d\n", ret);
+ return FALSE;
+ }
+ if (FALSE == _write_file(DECODE_MEM_PATH, g_decoded_data.data, (size_t)g_decoded_data.size)) {
+ fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", DECODE_MEM_PATH);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+gboolean _test_encode(const png_test_mode_e mode)
+{
+ int ret = 0;
+ /* for encoding jpeg to memory */
+ void *encoded_data = NULL;
+ size_t encoded_size = 0;
+
+ 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)) {
+ fprintf(stderr, "\t[PNG_testsuite] reading file error\n");
+ return FALSE;
+ }
+
+ /* test encoding jpeg */
+ if (mode == TEST_ENCODE_FILE) {
+ ret = mm_util_encode_to_png_file(&g_decoded_data, g_compression, ENCODE_FILE_PATH);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[PNG_testsuite] mm_util_jpeg_encode_to_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);
+ if (ret != MM_UTIL_ERROR_NONE) {
+ fprintf(stderr, "\t[PNG_testsuite] mm_util_jpeg_encode_to_file failed : %d\n", ret);
+ SAFE_FREE(encoded_data);
+ return FALSE;
+ }
+ if (FALSE == _write_file(ENCODE_MEM_PATH, encoded_data, (size_t)encoded_size)) {
+ fprintf(stderr, "\t[PNG_testsuite] writing decoded data failed : %s\n", ENCODE_MEM_PATH);
+ SAFE_FREE(encoded_data);
+ return FALSE;
+ }
+ }
+
+ SAFE_FREE(encoded_data);
+ return TRUE;
+}
+
+gboolean _test_auto()
+{
+ png_test_mode_e test_mode = TEST_DECODE_FILE;
+
+ while (test_mode < TEST_NUM) {
+ fprintf(stderr, "\t[PNG_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[PNG_testsuite] Not enough memory\n");
+ return FALSE;
+ }
+ }
+ /* test decoding jpeg */
+ if ((test_mode == TEST_DECODE_FILE) || (test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(test_mode)) {
+ fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
+ }
+ }
+
+ /* test encoding jpeg */
+ if ((test_mode == TEST_ENCODE_FILE) || (test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(test_mode)) {
+ fprintf(stderr, "\t[PNG_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s\' TEST FAIL\n", MODE_TO_STR[test_mode]);
+ return FALSE;
+ }
+ }
+
+ 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);
+ test_mode++;
+ }
+
+ return TRUE;
+}
+
+int main(int argc, char *argv[])
+{
if (argc < 2) {
- fprintf(stderr, "\t[usage]\n");
- fprintf(stderr, "\t\t1. decode : mm_util_png_testsuite decode filepath.png compression_level\n");
+ _print_help(argv[0]);
return 0;
}
- if (!strcmp("decode", argv[1])) {
- ret = mm_util_decode_from_png_file(&decoded_data, argv[2]);
- } else if (!strcmp("decode-mem", argv[1])) {
- if (_read_file(argv[2], &src, &src_size)) {
- ret = mm_util_decode_from_png_memory(&decoded_data, &src, src_size);
+ if (FALSE == _get_arguments(argc, argv)) {
+ fprintf(stderr, "\t[PNG_testsuite] _get_arguments failed\n");
+ goto out;
+ }
- free(src);
- src = NULL;
- } else {
- ret = MM_UTIL_ERROR_INVALID_OPERATION;
+ /* test full functions automatically */
+ if (g_test_mode == TEST_AUTO) {
+ if (FALSE == _test_auto())
+ fprintf(stderr, "\t[PNG_testsuite] _test_auto failed\n");
+ goto out;
+ }
+
+ /* test decoding jpeg */
+ if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_MEMORY)) {
+ if (FALSE == _test_decode(g_test_mode)) {
+ fprintf(stderr, "\t[PNG_testsuite] _test_decode(%s) failed\n", MODE_TO_STR[g_test_mode]);
+ goto out;
}
- } else {
- fprintf(stderr, "\tunknown command [%s]\n", argv[1]);
- return 0;
}
- if (ret != MM_UTIL_ERROR_NONE) {
- fprintf(stderr, "\tERROR is occurred %x\n", ret);
- } else {
- fprintf(stderr, "\tPNG OPERATION SUCCESS\n");
- {
- if (decoded_data.data) {
- fprintf(stderr, "\t##Decoded data##: %p\t width: %lu\t height:%lu\t size: %lu\n", decoded_data.data, (long unsigned int)decoded_data.width, (long unsigned int)decoded_data.height, (long unsigned int)decoded_data.size);
- char filename[BUFFER_SIZE] = { 0, };
- memset(filename, 0, BUFFER_SIZE);
- {
- snprintf(filename, BUFFER_SIZE, "%s%s", DECODE_RESULT_PATH, "png");
- }
-
- if (argv[3])
- compression = atoi(argv[3]);
-
- if (!strcmp("decode", argv[1])) {
- void *encoded_data;
- size_t size;
- ret = mm_util_encode_to_png_memory(&decoded_data, compression, &encoded_data, &size);
- fprintf(stderr, "Finished encoding encoded_data.size %zu\n", size);
- _write_file(filename, encoded_data, size);
- free(encoded_data);
- } else if (!strcmp("decode-mem", argv[1])) {
- ret = mm_util_encode_to_png_file(&decoded_data, compression, filename);
- }
- free(decoded_data.data);
- } else {
- fprintf(stderr, "\tDECODED data is NULL\n");
- }
+ /* test encoding jpeg */
+ if ((g_test_mode == TEST_ENCODE_FILE) || (g_test_mode == TEST_ENCODE_MEMORY)) {
+ if (FALSE == _test_encode(g_test_mode)) {
+ fprintf(stderr, "\t[PNG_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_FREE(g_decoded_data.data);
+
return 0;
}
projects / platform / core / multimedia / libmm-utility.git / commitdiff