test/image_util_testsuite.c

   1 /*
   2 * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <dlog.h>
  18 #include <glib.h>
  19 #include <limits.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <tzplatform_config.h>
  23 #include <image_util.h>
  24 #include <image_util_private.h>
  25
  26 /* logs for testsuite */
  27 #define VERSION                         "0.1.1 of 16 Aug 2019"
  28 /* prints log of menu-queue for testsuite */
  29 #define DEBUG_QUEUE                     0       /* 0:disable, 1:enable */
  30 /* saves the intermediate image to process name("transform" or "decode"), Not supported for encoding */
  31 #define DUMP_RAW_IMAGE          0       /* 0:disable, 1:enable */
  32
  33 /* commons for testsuite */
  34 #define MAX_STRING_LEN                  PATH_MAX
  35 #define MAX_AGIF_CNT                    100                     /* supports MAX_AGIF_CNT agif frames */
  36 #define IMAGE_UTIL_COLOR_NUM    IMAGE_UTIL_COLORSPACE_NV61 + 1
  37
  38 #define SAFE_FREE(src)                  { if (src) {free(src); src = NULL; } }
  39 #define SAFE_G_FREE(src)                { if (src) {g_free(src); src = NULL; } }
  40
  41 #define IS_RAW_FILE(x)                  ((g_strrstr(x, ".raw")) ? TRUE : FALSE)
  42
  43 #define RETM_IF(expr, fmt, arg...) do { \
  44                 if (expr) { \
  45                         g_print(fmt, ##arg);     \
  46                         return; \
  47                 } \
  48         } while (0)
  49 #define RETVM_IF(expr, val, fmt, arg...) do { \
  50                 if (expr) { \
  51                         g_print(fmt, ##arg);     \
  52                         return (val); \
  53                 } \
  54         } while (0)
  55
  56 /* output file */
  57 #define FILE_FOR_DUMP_RAW_IMAGE         tzplatform_mkpath(TZ_USER_CONTENT, "imgutil_test_raw")
  58 #define FILE_FOR_AUTO                           tzplatform_mkpath(TZ_USER_CONTENT, "imgutil_test_auto")
  59 #define FILE_FOR_ENCODE                         tzplatform_mkpath(TZ_USER_CONTENT, "imgutil_test_encode")
  60 #define FILE_FOR_ENCODE_AGIF            tzplatform_mkpath(TZ_USER_CONTENT, "imgutil_test_encode_agif")
  61
  62 /* parameters for testsuite */
  63 typedef enum {
  64         MAIN_MENU = 0,
  65         SET_PATH_MENU,
  66         SET_PATH_SUB_MENU,
  67         DECODE_MENU,
  68         ENCODE_MENU,
  69         ENCODE_AGIF_MENU,
  70         TRANSFORM_MENU,
  71
  72         /* set menu */
  73         SET_BUFFER_MENU = 20,
  74         SET_TO_BUFFER_MENU,
  75         SET_COLOR_MENU,
  76         SET_RAW_COLOR_MENU,
  77         SET_COMPRESSION_MENU,
  78         SET_CONVERT_MENU,
  79         SET_CROP_MENU,
  80         SET_DELAY_MENU,
  81         SET_DIR_MENU,
  82         SET_DOWNSCALE_MENU,
  83         SET_QUALITY_MENU,
  84         SET_RESIZE_MENU,
  85         SET_ROTATE_MENU,
  86         SET_SIZE_MENU,
  87         SET_TYPE_MENU,
  88         SET_LAST_MENU,
  89 } test_menu_state_e;
  90
  91 typedef struct {
  92         test_menu_state_e menu_state;
  93 } test_queue_menu_s;
  94
  95 typedef struct {
  96         unsigned int x;
  97         unsigned int y;
  98         unsigned int w;
  99         unsigned int h;
 100 } test_size_s;
 101
 102 typedef struct {
 103         /* for input path or dir */
 104         char *path;
 105
 106         /* for buffer test */
 107         gboolean has_buffer;
 108         unsigned char *buffer;
 109         size_t buffer_size;
 110
 111         /* for raw image test */
 112         gboolean is_raw;
 113         test_size_s size;
 114         image_util_colorspace_e color;
 115
 116         /* intermediate or result image for test */
 117         image_util_image_h image;
 118
 119         /* image count and handles for a-gif */
 120         unsigned int image_cnt;
 121         image_util_image_h images[MAX_AGIF_CNT];
 122 } test_complex_data_s;
 123
 124 /* for decode parameters */
 125 typedef struct {
 126         image_util_colorspace_e color;
 127         image_util_scale_e downscale;
 128 } test_decode_params_s;
 129
 130 /* for encode parameters */
 131 typedef struct {
 132         image_util_type_e type;
 133         int quality;
 134         image_util_png_compression_e compression;
 135         gboolean use_buffer;
 136 } test_encode_params_s;
 137
 138 /* for encode a-gif parameters */
 139 typedef struct {
 140         int delay;
 141         gboolean use_buffer;
 142 } test_encode_agif_params_s;
 143
 144 /* for transform parameters */
 145 typedef struct {
 146         gboolean has_convert_color;
 147         image_util_colorspace_e convert_color;
 148         gboolean has_crop;
 149         test_size_s crop_area;
 150         gboolean has_resize;
 151         test_size_s resize;
 152         gboolean has_rotation;
 153         image_util_rotation_e rotation;
 154 } test_transform_params_s;
 155
 156 /* for current menu to display */
 157 static test_menu_state_e g_current_menu = MAIN_MENU;
 158 /* for previous menu to go back */
 159 static test_menu_state_e g_previous_menu = MAIN_MENU;
 160
 161 /* for input data to process */
 162 static test_complex_data_s g_input_data;
 163
 164 /* decode */
 165 static test_decode_params_s g_decode_params;
 166 static test_complex_data_s g_decode_result;
 167 /* encode */
 168 static test_encode_params_s g_encode_params;
 169 static test_complex_data_s g_encode_result;
 170 /* encode a-gif */
 171 static test_encode_agif_params_s g_encode_agif_params;
 172 static test_complex_data_s g_encode_agif_result;
 173 /* transform */
 174 static test_transform_params_s g_transform_params;
 175 static test_complex_data_s g_transform_result;
 176
 177 /* for menu queue */
 178 static GQueue *g_queue_menu = NULL;
 179 /* for images queue to encode a-gif */
 180 static GQueue *g_queue_agif_images = NULL;
 181 /* for input data queue */
 182 static GQueue *g_queue_data = NULL;
 183
 184 static GMainLoop *g_mainloop = NULL;
 185 /* parameters for testsuite */
 186
 187
 188
 189 /* display menu for testsuite */
 190 static void __display_set(const char *text, const char *ex)
 191 {
 192         g_print("\n");
 193         g_print("\tPlease type 'b' to go back and 'q' to quit at any time.\n");
 194
 195         if (ex)
 196                 g_print("*** input %s [ex. %s] : ", text, ex);
 197         else
 198                 g_print("*** input %s: ", text);
 199 }
 200
 201 typedef enum {
 202         RAW_IMG_SET_COLOR,
 203         RAW_IMG_SET_SIZE,
 204         RAW_IMG_MENU_MAX,
 205 } test_raw_img_menu_e;
 206
 207 typedef struct {
 208         test_raw_img_menu_e e;
 209         const char *t;
 210 } test_raw_img_menu_s;
 211
 212 static const test_raw_img_menu_s g_disp_raw_img_menu[RAW_IMG_MENU_MAX] = {
 213         { RAW_IMG_SET_COLOR,            "set colorspace (opt. default=IMAGE_UTIL_COLORSPACE_RGBA8888)" },
 214         { RAW_IMG_SET_SIZE,                     "set width & height" },
 215 };
 216
 217 static void __display_set_raw_menu(void)
 218 {
 219         unsigned int idx = 0;
 220         g_print("\n");
 221         g_print("====================================================\n");
 222         g_print("   image-util Core-API test: Set raw data menu v%s\n", VERSION);
 223         g_print("----------------------------------------------------\n");
 224         for (idx = 0; idx < RAW_IMG_MENU_MAX; idx++)
 225                 g_print("%u. %s\n", g_disp_raw_img_menu[idx].e, g_disp_raw_img_menu[idx].t);
 226         g_print("b. back\n");
 227         g_print("q. quit\n");
 228         g_print("----------------------------------------------------\n");
 229         g_print("====================================================\n");
 230 }
 231
 232 typedef enum {
 233         DECODE_SET_BUFFER = 0,
 234         DECODE_SET_COLOR,
 235         DECODE_SET_DOWNSCALE,
 236         DECODE_RUN,
 237         DECODE_RUN_ASYNC,
 238         DECODE_RUN2,
 239         DECODE_RUN_ASYNC2,
 240         DECODE_SAVE_TO_JPEG,
 241         DECODE_MENU_MAX,
 242 } test_decode_menu_e;
 243
 244 typedef struct {
 245         test_decode_menu_e e;
 246         const char *t;
 247 } test_decode_menu_s;
 248
 249 static const test_decode_menu_s g_disp_decode_menu[DECODE_MENU_MAX] = {
 250         { DECODE_SET_BUFFER,            "set input buffer" },
 251         { DECODE_SET_COLOR,                     "set color (mand. default=IMAGE_UTIL_COLORSPACE_RGBA8888)" },
 252         { DECODE_SET_DOWNSCALE,         "set downscale (opt. for jpeg only)" },
 253         { DECODE_RUN,                           "decode run (will be deprecated)" },
 254         { DECODE_RUN_ASYNC,                     "decode run async (will be deprecated)" },
 255         { DECODE_RUN2,                          "decode run2" },
 256         { DECODE_RUN_ASYNC2,            "decode run async2" },
 257         { DECODE_SAVE_TO_JPEG,          "save decode result to jpg" },
 258 };
 259
 260 static void __display_decode_menu(void)
 261 {
 262         unsigned int idx = 0;
 263         g_print("\n");
 264         g_print("====================================================\n");
 265         g_print("   image-util Core-API test: Decode menu v%s\n", VERSION);
 266         g_print("----------------------------------------------------\n");
 267         for (idx = 0; idx < DECODE_MENU_MAX; idx++)
 268                 g_print("%u. %s\n", g_disp_decode_menu[idx].e, g_disp_decode_menu[idx].t);
 269         g_print("b. back\n");
 270         g_print("q. quit\n");
 271         g_print("----------------------------------------------------\n");
 272         g_print("====================================================\n");
 273 }
 274
 275 typedef enum {
 276         ENCODE_SET_TYPE = 0,
 277         ENCODE_SET_QUALITY,
 278         ENCODE_SET_COMPRESIION,
 279         ENCODE_SET_TO_BUFFER,
 280         ENCODE_RUN,
 281         ENCODE_RUN_ASYNC,
 282         ENCODE_RUN_TO_FILE,
 283         ENCODE_RUN_TO_BUFFER,
 284         ENCODE_RUN_ASYNC_TO_FILE,
 285         ENCODE_RUN_ASYNC_TO_BUFFER,
 286         ENCODE_MENU_MAX,
 287 } test_encode_menu_e;
 288
 289 typedef struct {
 290         test_encode_menu_e e;
 291         const char *t;
 292 } test_encode_menu_s;
 293
 294 static const test_encode_menu_s g_disp_encode_menu[ENCODE_MENU_MAX] = {
 295         { ENCODE_SET_TYPE,                              "set image_type (mand. default=IMAGE_UTIL_JPEG)" },
 296         { ENCODE_SET_QUALITY,                   "set quality (opt. for jpeg only)" },
 297         { ENCODE_SET_COMPRESIION,               "set compression (opt. for png only)" },
 298         { ENCODE_SET_TO_BUFFER,                 "set output buffer (opt. deprecated)" },
 299         { ENCODE_RUN,                                   "encode run (will be deprecated)" },
 300         { ENCODE_RUN_ASYNC,                             "encode run async (will be deprecated)" },
 301         { ENCODE_RUN_TO_FILE,                   "encode run to file" },
 302         { ENCODE_RUN_TO_BUFFER,                 "encode run to buffer" },
 303         { ENCODE_RUN_ASYNC_TO_FILE,             "encode run async to file" },
 304         { ENCODE_RUN_ASYNC_TO_BUFFER,   "encode run async to buffer" },
 305 };
 306
 307 static void __display_encode_menu(void)
 308 {
 309         unsigned int idx = 0;
 310         g_print("\n");
 311         g_print("====================================================\n");
 312         g_print("   image-util Core-API test: Encode menu v%s\n", VERSION);
 313         g_print("----------------------------------------------------\n");
 314         for (idx = 0; idx < ENCODE_MENU_MAX; idx++)
 315                 g_print("%u. %s\n", g_disp_encode_menu[idx].e, g_disp_encode_menu[idx].t);
 316         g_print("b. back\n");
 317         g_print("q. quit\n");
 318         g_print("----------------------------------------------------\n");
 319         g_print("====================================================\n");
 320 }
 321
 322 typedef enum {
 323         ENCODE_AGIF_SET_DIR = 0,
 324         ENCODE_AGIF_SET_DELAY,
 325         ENCODE_AGIF_SET_TO_BUFFER,
 326         ENCODE_AGIF_RUN,
 327         ENCODE_AGIF_RUN_ASYNC,
 328         ENCODE_AGIF_SAVE_TO_FILE,
 329         ENCODE_AGIF_SAVE_TO_BUFFER,
 330         ENCODE_AGIF_MENU_MAX,
 331 } test_encode_agif_menu_e;
 332
 333 typedef struct {
 334         test_encode_agif_menu_e e;
 335         const char *t;
 336 } test_encode_agif_menu_s;
 337
 338 static const test_encode_agif_menu_s g_disp_encode_agif_menu[ENCODE_AGIF_MENU_MAX] = {
 339         { ENCODE_AGIF_SET_DIR,                  "set directory" },
 340         { ENCODE_AGIF_SET_DELAY,                "set dealy time (mand. default = 100)" },
 341         { ENCODE_AGIF_SET_TO_BUFFER,    "set output buffer (opt. will be deprecated)" },
 342         { ENCODE_AGIF_RUN,                              "run agif (will be deprecated)" },
 343         { ENCODE_AGIF_RUN_ASYNC,                "run async agif (will be deprecated)" },
 344         { ENCODE_AGIF_SAVE_TO_FILE,             "add frame by frame and save to file" },
 345         { ENCODE_AGIF_SAVE_TO_BUFFER,   "add frame by frame and save to buffer" },
 346 };
 347
 348 static void __display_encode_agif_menu(void)
 349 {
 350         unsigned int idx = 0;
 351         g_print("\n");
 352         g_print("====================================================\n");
 353         g_print("   image-util Core-API test: Encode A-GIF menu v%s\n", VERSION);
 354         g_print("----------------------------------------------------\n");
 355         for (idx = 0; idx < ENCODE_AGIF_MENU_MAX; idx++)
 356                 g_print("%u. %s\n", g_disp_encode_agif_menu[idx].e, g_disp_encode_agif_menu[idx].t);
 357         g_print("b. back\n");
 358         g_print("q. quit\n");
 359         g_print("----------------------------------------------------\n");
 360         g_print("====================================================\n");
 361 }
 362
 363 typedef enum {
 364         TRANSFORM_SET_CONVERT = 0,
 365         TRANSFORM_SET_CROP,
 366         TRANSFORM_SET_RESIZE,
 367         TRANSFORM_SET_ROTATE,
 368         TRANSFORM_RUN,
 369         TRANSFORM_RUN2,
 370         TRANSFORM_RUN2_ASYNC,
 371         TRANSFORM_MENU_MAX,
 372 } test_transform_menu_e;
 373
 374 typedef struct {
 375         test_transform_menu_e e;
 376         const char *t;
 377 } test_transform_menu_s;
 378
 379 static const test_transform_menu_s g_disp_transform_menu[TRANSFORM_MENU_MAX] = {
 380         { TRANSFORM_SET_CONVERT,        "set convert" },
 381         { TRANSFORM_SET_CROP,           "set crop" },
 382         { TRANSFORM_SET_RESIZE,         "set resize" },
 383         { TRANSFORM_SET_ROTATE,         "set rotate" },
 384         { TRANSFORM_RUN,                        "transform run" },
 385         { TRANSFORM_RUN2,                       "transform run2" },
 386         { TRANSFORM_RUN2_ASYNC,         "transform run2 async" },
 387 };
 388
 389 static void __display_transform_menu(void)
 390 {
 391         unsigned int idx = 0;
 392         g_print("\n");
 393         g_print("====================================================\n");
 394         g_print("   image-util Core-API test: Transform menu v%s\n", VERSION);
 395         g_print("----------------------------------------------------\n");
 396         for (idx = 0; idx < TRANSFORM_MENU_MAX; idx++)
 397                 g_print("%u. %s\n", g_disp_transform_menu[idx].e, g_disp_transform_menu[idx].t);
 398         g_print("b. back\n");
 399         g_print("q. quit\n");
 400         g_print("----------------------------------------------------\n");
 401         g_print("====================================================\n");
 402 }
 403
 404 typedef enum {
 405         TEST_AUTO = 0,
 406         TEST_DECODE,
 407         TEST_ENCODE,
 408         TEST_ENCODE_AGIF,
 409         TEST_TRANSFORM,
 410         SET_PATH,
 411         MAIN_MENU_MAX,
 412 } test_main_menu_e;
 413
 414 typedef struct {
 415         test_main_menu_e e;
 416         const char *t;
 417 } test_main_menu_s;
 418
 419 static const test_main_menu_s g_disp_main_menu[MAIN_MENU_MAX] = {
 420         { TEST_AUTO,                    "test auto" },
 421         { TEST_DECODE,                  "test decode" },
 422         { TEST_ENCODE,                  "test encode" },
 423         { TEST_ENCODE_AGIF,             "test encode a-gif" },
 424         { TEST_TRANSFORM,               "test transform" },
 425         { SET_PATH,                             "set path" },
 426 };
 427
 428 static void __display_main_menu(void)
 429 {
 430         unsigned int idx = 0;
 431         g_print("\n");
 432         g_print("====================================================\n");
 433         g_print("   image-util Core-API test: Main menu v%s\n", VERSION);
 434         g_print("----------------------------------------------------\n");
 435         for (idx = 0; idx < MAIN_MENU_MAX; idx++)
 436                 g_print("%u. %s\n", g_disp_main_menu[idx].e, g_disp_main_menu[idx].t);
 437         g_print("q. quit\n");
 438         g_print("----------------------------------------------------\n");
 439         g_print("====================================================\n");
 440 }
 441
 442 static void __display_menu(test_menu_state_e menu_state)
 443 {
 444         switch(menu_state) {
 445         case DECODE_MENU:
 446                 __display_decode_menu();
 447                 break;
 448         case ENCODE_MENU:
 449                 __display_encode_menu();
 450                 break;
 451         case ENCODE_AGIF_MENU:
 452                 __display_encode_agif_menu();
 453                 break;
 454         case TRANSFORM_MENU:
 455                 __display_transform_menu();
 456                 break;
 457
 458         /* set menus */
 459         case SET_PATH_MENU:
 460                 __display_set("path", "/home/owner/media/test.jpg");
 461                 break;
 462         case SET_DIR_MENU:
 463                 __display_set("dir", "/home/owner/media/Images");
 464                 break;
 465         case SET_PATH_SUB_MENU:
 466                 __display_set_raw_menu();
 467                 break;
 468
 469         case SET_BUFFER_MENU:
 470                 __display_set("set buffer", "yes/no");
 471                 break;
 472         case SET_COLOR_MENU:
 473         case SET_RAW_COLOR_MENU:
 474         case SET_CONVERT_MENU:
 475                 __display_set("colorspace", "i420:2, rgb:7, argb:8, rgba:10");
 476                 break;
 477         case SET_COMPRESSION_MENU:
 478                 __display_set("comprssion", "0(NoC/HighQ)~9(MaxC/LowQ)");
 479                 break;
 480         case SET_CROP_MENU:
 481                 __display_set("crop", "(sx)x(sy)x(w)x(h) 0x0x1920x1080");
 482                 break;
 483         case SET_DELAY_MENU:
 484                 __display_set("delay", "20~");
 485                 break;
 486         case SET_DOWNSCALE_MENU:
 487                 __display_set("downscale", "0(1/1)~3(1/8)");
 488                 break;
 489         case SET_QUALITY_MENU:
 490                 __display_set("quality", "1(LowQ)~100(HighQ)");
 491                 break;
 492         case SET_RESIZE_MENU:
 493         case SET_SIZE_MENU:
 494                 __display_set("size", "1920x1080");
 495                 break;
 496         case SET_ROTATE_MENU:
 497                 __display_set("rotation", "0:none, 1:90, 2:180, 3:270");
 498                 break;
 499         case SET_TYPE_MENU:
 500                 __display_set("image_type", "0:jpeg, 1:png, 2:gif, 3:bmp");
 501                 break;
 502         /* set menus */
 503
 504         case MAIN_MENU:
 505         default:
 506                 __display_main_menu();
 507                 break;
 508         }
 509 }
 510 /* display menu for testsuite */
 511
 512
 513
 514 /* internal functions for testsuite */
 515 GCond g_thread_cond;
 516 GMutex g_thread_mutex;
 517
 518 void __wait()
 519 {
 520         g_mutex_lock(&g_thread_mutex);
 521         g_print("\t[__wait] waiting... until finishing\n");
 522         g_cond_wait(&g_thread_cond, &g_thread_mutex);
 523         g_print("\t[__wait] get signal from callback\n");
 524         g_mutex_unlock(&g_thread_mutex);
 525 }
 526
 527 void __signal()
 528 {
 529         g_mutex_lock(&g_thread_mutex);
 530         g_cond_signal(&g_thread_cond);
 531         g_print("\t[__signal] send signal to test proc\n");
 532         g_mutex_unlock(&g_thread_mutex);
 533 }
 534
 535 static gboolean __read_file(char *path, void **data, size_t *length)
 536 {
 537         FILE *fp = NULL;
 538         long len = 0;
 539
 540         if (!path || !data || length == 0) {
 541                 g_print("\t[__read_file] invalid data\n");
 542                 return FALSE;
 543         }
 544
 545         g_print("\t[__read_file] %s read\n", path);
 546
 547         fp = fopen(path, "r");
 548         if (fp == NULL) {
 549                 g_print("\t[__read_file] fopen failed (%d)\n", errno);
 550                 return FALSE;
 551         }
 552
 553         if (fseek(fp, 0, SEEK_END) < 0) {
 554                 g_print("\t[__read_file] fseek failed\n");
 555                 fclose(fp);
 556                 return FALSE;
 557         }
 558
 559         len = ftell(fp);
 560         if (len < 0) {
 561                 g_print("\t[__read_file] ftell failed\n");
 562                 fclose(fp);
 563                 return FALSE;
 564         }
 565
 566         rewind(fp);
 567         *data = (void *)calloc(1, (size_t)len);
 568         if (*data == NULL) {
 569                 g_print("\t[__read_file] memory allocation failed\n");
 570                 fclose(fp);
 571                 return FALSE;
 572         }
 573
 574         *length = fread(*data, 1, (size_t)len, fp);
 575         if (*length != (size_t)len) {
 576                 g_print("\t[__read_file] fread failed\n");
 577         }
 578
 579         fclose(fp);
 580
 581         if (*data == NULL) {
 582                 *length = 0;
 583                 return FALSE;
 584         }
 585
 586         *length = (size_t)len;
 587
 588         g_print("\t[__read_file] %s %zu read DONE\n", path, *length);
 589
 590         return TRUE;
 591 }
 592
 593 static gboolean __write_file(const char *path, void *data, size_t length)
 594 {
 595         FILE *fp = NULL;
 596         size_t len = 0;
 597
 598         if (!path || !data || length == 0) {
 599                 g_print("\t[__write_file] invalid data\n");
 600                 return FALSE;
 601         }
 602
 603         g_print("\t[__write_file] %s %p %zu write\n", path, data, length);
 604
 605         fp = fopen(path, "w");
 606         if (fp == NULL) {
 607                 g_print("\t[__write_file] fopen failed (%d)\n", errno);
 608                 return FALSE;
 609         }
 610
 611         len = fwrite(data, 1, length, fp);
 612         if (len != length) {
 613                 g_print("\t[__write_file] fwrite failed\n");
 614         }
 615
 616         fclose(fp);
 617         fp = NULL;
 618
 619         g_print("\t[__write_file] %s write DONE\n", path);
 620
 621         return TRUE;
 622 }
 623
 624 #if DUMP_RAW_IMAGE
 625 static int __write_jpeg(const char *name, image_util_image_h image)
 626 {
 627         int ret = IMAGE_UTIL_ERROR_NONE;
 628         image_util_encode_h handle = NULL;
 629         char *path = NULL;
 630
 631         path = g_strdup_printf("%s_%s.jpg", FILE_FOR_DUMP_RAW_IMAGE, name);
 632         RETVM_IF(!path, IMAGE_UTIL_ERROR_OUT_OF_MEMORY, "Memory allocation failed");
 633
 634         ret = image_util_encode_create(IMAGE_UTIL_JPEG, &handle);
 635         if (ret != IMAGE_UTIL_ERROR_NONE) {
 636                 g_print("image_util_decode_create failed %d", ret);
 637                 return ret;
 638         }
 639
 640         ret = image_util_encode_run_to_file(handle, image, path);
 641         if (ret != IMAGE_UTIL_ERROR_NONE) {
 642                 g_print("image_util_encode_run_to_file failed %d", ret);
 643                 goto ERROR;
 644         }
 645
 646 ERROR:
 647         image_util_encode_destroy(handle);
 648
 649         return ret;
 650 }
 651 #endif
 652
 653 static void __queue_free_func(gpointer data)
 654 {
 655         SAFE_FREE(data);
 656 }
 657
 658 static gboolean __safe_atoui(char *buffer, unsigned int *ui)
 659 {
 660         char *end = NULL;
 661         errno = 0;
 662         if (buffer == NULL || ui == NULL)
 663                 return FALSE;
 664
 665         const long sl = strtol(buffer, &end, 10);
 666
 667         if (end == buffer)
 668                 return FALSE;
 669         if ('\0' != *end)
 670                 return FALSE;
 671         if ((LONG_MIN == sl || LONG_MAX == sl) && (ERANGE == errno))
 672                 return FALSE;
 673         if (sl < 0)
 674                 return FALSE;
 675
 676         *ui = (unsigned int)sl;
 677
 678         return TRUE;
 679 }
 680
 681 static void __decode_func(gpointer data, gpointer user_data)
 682 {
 683         int ret = IMAGE_UTIL_ERROR_NONE;
 684         image_util_decode_h decoder = (image_util_decode_h)user_data;
 685         char *path = (char *)data;
 686
 687         if (path == NULL || strlen(path) == 0)
 688                 return;
 689
 690         ret = image_util_decode_set_input_path(decoder, path);
 691         if (ret != IMAGE_UTIL_ERROR_NONE) {
 692                 g_print("image_util_decode_set_input_path failed %d\n", ret);
 693                 return;
 694         }
 695
 696         ret = image_util_decode_run2(decoder, &g_input_data.images[g_input_data.image_cnt]);
 697         if (ret != IMAGE_UTIL_ERROR_NONE) {
 698                 g_print("image_util_decode_run2 failed %d\n", ret);
 699                 return;
 700         }
 701         g_input_data.image_cnt++;
 702 }
 703
 704 static gboolean __decode_file_in_dir()
 705 {
 706         int ret = IMAGE_UTIL_ERROR_NONE;
 707         image_util_decode_h decoder = NULL;
 708
 709         ret = image_util_decode_create(&decoder);
 710         if (ret != IMAGE_UTIL_ERROR_NONE) {
 711                 g_print("image_util_decode_create failed %d\n", ret);
 712                 return FALSE;
 713         }
 714
 715         g_queue_foreach(g_queue_agif_images, __decode_func, decoder);
 716
 717         if (g_input_data.image_cnt == 0) {
 718                 g_print("No valid image\n");
 719                 return FALSE;
 720         }
 721
 722         image_util_decode_destroy(decoder);
 723
 724         g_print("%u valid image have been decoded.\n", g_input_data.image_cnt);
 725
 726         return TRUE;
 727 }
 728
 729 static int __sort_compare(gconstpointer a, gconstpointer b, gpointer user_data)
 730 {
 731         const char *_a = (const char *)a;
 732         const char *_b = (const char *)b;
 733         if (strlen(_a) < strlen(_b))
 734                 return -1;
 735
 736         if (strlen(_a) > strlen(_b))
 737                 return 1;
 738
 739         return g_ascii_strcasecmp(_a, _b);
 740 }
 741
 742 static gboolean __set_input_dir(const char *path)
 743 {
 744         struct dirent *dp = NULL;
 745         DIR *fd = NULL;
 746
 747         if (path == NULL || strlen(path) == 0)
 748                 return FALSE;
 749
 750         if (!g_queue_agif_images) {
 751                 g_queue_agif_images = g_queue_new();
 752                 if (!g_queue_agif_images) {
 753                         g_print("g_queue_new failed\n");
 754                         return FALSE;
 755                 }
 756         }
 757
 758         fd = opendir(path);
 759         if (fd == NULL) {
 760                 g_print("\tlistdir: can't open %s\n", path);
 761                 return FALSE;
 762         }
 763
 764         g_queue_free_full(g_queue_agif_images, __queue_free_func);
 765
 766         /* read files in dir */
 767         while ((dp = readdir(fd)) != NULL) {
 768                 if (strlen(dp->d_name) == 0)
 769                         continue;
 770                 if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
 771                         continue;       /* skip self and parent */
 772
 773                 g_queue_push_tail(g_queue_agif_images, g_strdup_printf("%s/%s", path, dp->d_name));
 774         }
 775
 776         closedir(fd);
 777
 778         if (g_queue_get_length(g_queue_agif_images) == 0) {
 779                 g_print("\tNo Test File in directory(%s)!\n", path);
 780                 return FALSE;
 781         }
 782
 783         /* sort files */
 784         g_queue_sort(g_queue_agif_images, __sort_compare, NULL);
 785
 786         /* decode files of dir */
 787         if (!__decode_file_in_dir()) {
 788                 g_print("Fail to decode file from dir! %s\n", path);
 789                 return FALSE;
 790         }
 791
 792         return TRUE;
 793 }
 794
 795 static gboolean __set_input_path(const char *path)
 796 {
 797         if (path == NULL || strlen(path) == 0)
 798                 return FALSE;
 799
 800         SAFE_G_FREE(g_input_data.path);
 801
 802         g_input_data.path = g_strdup(path);
 803         if (!g_input_data.path) {
 804                 g_print("Memory allocation failed\n");
 805                 return FALSE;
 806         }
 807
 808         if (g_file_test(path, G_FILE_TEST_IS_DIR)) {
 809                 g_print("file path is a directory (%s)\n", path);
 810                 return __set_input_dir(path);
 811         }
 812
 813         return TRUE;
 814 }
 815
 816 static gboolean __set_input_crop_area(const char *data, test_size_s *size)
 817 {
 818         gchar **params = NULL;
 819         gboolean ret = FALSE;
 820
 821         if (data == NULL || strlen(data) == 0)
 822                 return FALSE;
 823
 824         params = g_strsplit(data, ",", 0);
 825
 826         if (params == NULL || params[0] == NULL || params[1] == NULL || params[2] == NULL || params[3] == NULL)
 827                 return FALSE;
 828
 829         if (!__safe_atoui(params[0], &size->x)) {
 830                 g_print("wrong width! %s\n", params[0]);
 831                 goto ERROR;
 832         }
 833         if (!__safe_atoui(params[1], &size->y)) {
 834                 g_print("wrong height! %s\n", params[1]);
 835                 goto ERROR;
 836         }
 837
 838         if (!__safe_atoui(params[2], &size->w)) {
 839                 g_print("wrong width! %s\n", params[0]);
 840                 goto ERROR;
 841         }
 842         if (!__safe_atoui(params[3], &size->h)) {
 843                 g_print("wrong height! %s\n", params[1]);
 844                 goto ERROR;
 845         }
 846
 847         ret = TRUE;
 848
 849 ERROR:
 850         g_strfreev(params);
 851
 852         return ret;
 853 }
 854
 855 static gboolean __set_input_size(const char *data, test_size_s *size)
 856 {
 857         gchar **params = NULL;
 858         gboolean ret = FALSE;
 859
 860         if (data == NULL || strlen(data) == 0)
 861                 return FALSE;
 862
 863         params = g_strsplit(data, "x", 0);
 864
 865         if (params == NULL || params[0] == NULL || params[1] == NULL)
 866                 return FALSE;
 867
 868         if (!__safe_atoui(params[0], &size->w)) {
 869                 g_print("wrong width! %s\n", params[0]);
 870                 goto ERROR;
 871         }
 872         if (!__safe_atoui(params[1], &size->h)) {
 873                 g_print("wrong height! %s\n", params[1]);
 874                 goto ERROR;
 875         }
 876
 877         ret = TRUE;
 878
 879 ERROR:
 880         g_strfreev(params);
 881
 882         return ret;
 883 }
 884
 885 static int __get_raw_data(test_complex_data_s *test_data)
 886 {
 887         int ret = IMAGE_UTIL_ERROR_NONE;
 888         void *buffer = NULL;
 889         size_t buffer_size = 0;
 890
 891         if (test_data->is_raw) {
 892                 if (!__read_file(test_data->path, &buffer, &buffer_size)) {
 893                         g_print("__read_file failed %s\n", test_data->path);
 894                         return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
 895                 }
 896
 897                 ret = image_util_create_image(test_data->size.w, test_data->size.h, test_data->color,
 898                                                 buffer, buffer_size, &test_data->image);
 899                 if (ret != IMAGE_UTIL_ERROR_NONE)
 900                         g_print("image_util_create_image failed %d\n", ret);
 901         }
 902
 903         return ret;
 904 }
 905
 906 static unsigned int g_num_of_file = 0;
 907 static void __set_auto_file(image_util_type_e image_type, char **path)
 908 {
 909         char ext[4];
 910
 911         SAFE_G_FREE(*path);
 912
 913         switch (image_type) {
 914         case IMAGE_UTIL_JPEG:
 915                 snprintf(ext, 4, "%s", "jpg");
 916                 break;
 917         case IMAGE_UTIL_PNG:
 918                 snprintf(ext, 4, "%s", "png");
 919                 break;
 920         case IMAGE_UTIL_GIF:
 921                 snprintf(ext, 4, "%s", "gif");
 922                 break;
 923         case IMAGE_UTIL_BMP:
 924                 snprintf(ext, 4, "%s", "bmp");
 925                 break;
 926         default:
 927                 g_print("Not supported encode format!\n");
 928                 return;
 929         }
 930
 931         *path = g_strdup_printf("%s_%02d.%s", FILE_FOR_AUTO, g_num_of_file++, ext);
 932
 933         g_print("\t__set_auto_file: %s!\n", *path);
 934 }
 935
 936 static void __set_encode_file(image_util_type_e image_type, const char *base, char **path)
 937 {
 938         char ext[4];
 939
 940         SAFE_G_FREE(*path);
 941
 942         switch (image_type) {
 943         case IMAGE_UTIL_JPEG:
 944                 snprintf(ext, 4, "%s", "jpg");
 945                 break;
 946         case IMAGE_UTIL_PNG:
 947                 snprintf(ext, 4, "%s", "png");
 948                 break;
 949         case IMAGE_UTIL_GIF:
 950                 snprintf(ext, 4, "%s", "gif");
 951                 break;
 952         case IMAGE_UTIL_BMP:
 953                 snprintf(ext, 4, "%s", "bmp");
 954                 break;
 955         default:
 956                 g_print("Not supported encode format!\n");
 957                 return;
 958         }
 959
 960         *path = g_strdup_printf("%s.%s", base, ext);
 961 }
 962 /* internal functions for testsuite */
 963
 964
 965 /* callback functions for test */
 966 static void __decode_completed_cb(int error_code, void *user_data, unsigned long width, unsigned long height, unsigned long long size)
 967 {
 968         test_complex_data_s *result = (test_complex_data_s *)user_data;
 969
 970         g_print("\t__decode_completed_cb invoked %d\n", error_code);
 971
 972         if (error_code != IMAGE_UTIL_ERROR_NONE) {
 973                 g_print("Fail to decode image %d\n", error_code);
 974                 __signal();
 975                 return;
 976         }
 977
 978         result->size.w = (unsigned int)width;
 979         result->size.h = (unsigned int)height;
 980         result->buffer_size = (size_t)size;
 981         __signal();
 982 }
 983
 984 static void __decode_completed2_cb(int error_code, image_util_image_h image, void *user_data)
 985 {
 986         int ret = IMAGE_UTIL_ERROR_NONE;
 987         test_complex_data_s *result = (test_complex_data_s *)user_data;
 988
 989         g_print("\t__decode_completed2_cb invoked %d\n", error_code);
 990
 991         if (error_code != IMAGE_UTIL_ERROR_NONE) {
 992                 g_print("Fail to decode image %d", error_code);
 993                 __signal();
 994                 return;
 995         }
 996
 997         ret = image_util_clone_image(image, &result->image);
 998         if (ret != IMAGE_UTIL_ERROR_NONE)
 999                 g_print("image_util_clone_image failed %d\n", ret);
1000
1001         __signal();
1002 }
1003
1004 static void __encode_completed_cb(int error_code, void *user_data, unsigned long long size)
1005 {
1006         test_complex_data_s *result = (test_complex_data_s *)user_data;
1007
1008         g_print("\t__encode_to_file_completed_cb invoked %d\n", error_code);
1009
1010         if (error_code != IMAGE_UTIL_ERROR_NONE)
1011                 g_print("Fail to decode image %d\n", error_code);
1012
1013         result->buffer_size = (size_t)size;
1014         __signal();
1015 }
1016
1017 static void __encode_to_file_completed_cb(image_util_error_e error_code, void *user_data)
1018 {
1019         g_print("\t__encode_to_file_completed_cb invoked %d\n", error_code);
1020
1021         if (error_code != IMAGE_UTIL_ERROR_NONE)
1022                 g_print("Fail to decode image %d\n", error_code);
1023
1024         __signal();
1025 }
1026
1027 static void __encode_to_buffer_completed_cb(image_util_error_e error_code, unsigned char *buffer, size_t buffer_size, void *user_data)
1028 {
1029         test_complex_data_s *result = (test_complex_data_s *)user_data;
1030
1031         g_print("\t__encode_to_buffer_completed_cb invoked %d\n", error_code);
1032
1033         if (error_code != IMAGE_UTIL_ERROR_NONE) {
1034                 g_print("Fail to decode image %d\n", error_code);
1035                 __signal();
1036                 return;
1037         }
1038
1039         result->buffer = calloc(1, buffer_size);
1040         if (result->buffer) {
1041                 memcpy(result->buffer, buffer, buffer_size);
1042                 result->buffer_size = buffer_size;
1043         }
1044         __signal();
1045 }
1046
1047 static void __transform_completed_cb(media_packet_h *dst, int error_code, void *user_data)
1048 {
1049         media_packet_h *result = (media_packet_h *)user_data;
1050
1051         g_print("\t__transform_completed_cb invoked %d\n", error_code);
1052
1053         if (error_code != IMAGE_UTIL_ERROR_NONE) {
1054                 g_print("Fail to transform image %d\n", error_code);
1055                 __signal();
1056                 return;
1057         }
1058
1059         *result = *dst;
1060
1061         __signal();
1062 }
1063
1064 static void __transform_completed2_cb(image_util_image_h dst, int error_code, void *user_data)
1065 {
1066         int ret = IMAGE_UTIL_ERROR_NONE;
1067         test_complex_data_s *result = (test_complex_data_s *)user_data;
1068
1069         g_print("\t__transform_completed2_cb invoked %d\n", error_code);
1070
1071         if (error_code != IMAGE_UTIL_ERROR_NONE) {
1072                 g_print("Fail to transform image %d\n", error_code);
1073                 __signal();
1074                 return;
1075         }
1076
1077         ret = image_util_clone_image(dst, &result->image);
1078         if (ret != IMAGE_UTIL_ERROR_NONE)
1079                 g_print("image_util_clone_image failed %d\n", ret);
1080
1081         __signal();
1082 }
1083
1084 /* callback functions for test */
1085
1086
1087 /* test functions for testsuite */
1088 /* decode JPE, PNG, GIF and BMP with params
1089  * input : use path or buffer(buffer_size)
1090  * output : use image
1091  */
1092 static int __run_decode(test_decode_menu_e menu, test_complex_data_s *input,
1093                 test_decode_params_s *params, test_complex_data_s *result)
1094 {
1095         int ret = IMAGE_UTIL_ERROR_NONE;
1096         image_util_decode_h handle = NULL;
1097         unsigned long width = 0;
1098         unsigned long height = 0;
1099         unsigned long long buffer_size = 0;
1100
1101         if (!input || !params || !result) {
1102                 g_print("invalid parameter!!! input: %p, params: %p, result: %p\n", input, params, result);
1103                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1104         }
1105
1106         if (result->image) {
1107                 image_util_destroy_image(result->image);
1108                 result->image = NULL;
1109         }
1110
1111         ret = image_util_decode_create(&handle);
1112         if (ret != IMAGE_UTIL_ERROR_NONE) {
1113                 g_print("image_util_decode_create failed %d\n", ret);
1114                 return ret;
1115         }
1116
1117         if (input->has_buffer) {
1118                 ret = image_util_decode_set_input_buffer(handle, input->buffer, input->buffer_size);
1119                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1120                         g_print("image_util_decode_set_input_buffer failed %d\n", ret);
1121                         goto ERROR;
1122                 }
1123         } else {
1124                 ret = image_util_decode_set_input_path(handle, input->path);
1125                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1126                         g_print("image_util_decode_set_input_path failed %d\n", ret);
1127                         goto ERROR;
1128                 }
1129         }
1130
1131         ret = image_util_decode_set_colorspace(handle, params->color);
1132         if (ret != IMAGE_UTIL_ERROR_NONE) {
1133                 g_print("image_util_decode_set_colorspace failed %d\n", ret);
1134                 goto ERROR;
1135         }
1136
1137         switch(menu) {
1138         case DECODE_RUN:
1139                 ret = image_util_decode_set_output_buffer(handle, &result->buffer);
1140                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1141                         g_print("image_util_decode_run failed %d\n", ret);
1142                         break;
1143                 }
1144
1145                 ret = image_util_decode_run(handle, &width, &height, &buffer_size);
1146                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1147                         g_print("image_util_decode_run failed %d\n", ret);
1148                         break;
1149                 }
1150
1151                 ret = image_util_create_image((unsigned int)width, (unsigned int)height, params->color,
1152                                         result->buffer, buffer_size, &result->image);
1153                 SAFE_FREE(result->buffer);
1154                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1155                         g_print("image_util_create_image failed %d\n", ret);
1156                         break;
1157                 }
1158                 break;
1159
1160         case DECODE_RUN_ASYNC:
1161                 ret = image_util_decode_set_output_buffer(handle, &result->buffer);
1162                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1163                         g_print("image_util_decode_run failed %d\n", ret);
1164                         break;
1165                 }
1166
1167                 ret = image_util_decode_run_async(handle, __decode_completed_cb, result);
1168                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1169                         g_print("image_util_decode_run failed %d\n", ret);
1170                         break;
1171                 }
1172                 __wait();
1173
1174                 ret = image_util_create_image(result->size.w, result->size.h, params->color,
1175                                         result->buffer, result->buffer_size, &result->image);
1176                 SAFE_FREE(result->buffer);
1177                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1178                         g_print("image_util_create_image failed %d\n", ret);
1179                         break;
1180                 }
1181                 break;
1182
1183         case DECODE_RUN2:
1184                 ret = image_util_decode_run2(handle, &result->image);
1185                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1186                         g_print("image_util_decode_run2 failed %d\n", ret);
1187                         goto ERROR;
1188                 }
1189                 break;
1190
1191         case DECODE_RUN_ASYNC2:
1192                 ret = image_util_decode_run_async2(handle, __decode_completed2_cb, result);
1193                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1194                         g_print("image_util_decode_run2 failed %d\n", ret);
1195                         goto ERROR;
1196                 }
1197                 __wait();
1198                 break;
1199
1200         default:
1201                 g_print("wrong decode menu %u\n", menu);
1202                 break;
1203         }
1204
1205 ERROR:
1206         image_util_decode_destroy(handle);
1207
1208         return ret;
1209 }
1210
1211 /* encode JPE, PNG, GIF and BMP with params
1212  * input : use image
1213  * output : use path or buffer(buffer_size)
1214  */
1215 static int __run_encode(test_encode_menu_e menu, test_complex_data_s *input,
1216                 test_encode_params_s *params, test_complex_data_s *result)
1217 {
1218         int ret = IMAGE_UTIL_ERROR_NONE;
1219         image_util_encode_h handle = NULL;
1220         unsigned long long buffer_size = 0;
1221
1222         if (!input || !params || !result) {
1223                 g_print("invalid parameter!!! input: %p, params: %p, result: %p\n", input, params, result);
1224                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1225         }
1226
1227         ret = __get_raw_data(input);
1228         if (ret != IMAGE_UTIL_ERROR_NONE) {
1229                 g_print("__get_raw_data failed %d\n", ret);
1230                 return ret;
1231         }
1232
1233         if (result->buffer) {
1234                 SAFE_FREE(result->buffer);
1235                 result->image = NULL;
1236         }
1237
1238         ret = image_util_encode_create(params->type, &handle);
1239         if (ret != IMAGE_UTIL_ERROR_NONE) {
1240                 g_print("image_util_decode_create failed %d\n", ret);
1241                 return ret;
1242         }
1243
1244         if (params->type == IMAGE_UTIL_JPEG) {
1245                 ret = image_util_encode_set_quality(handle, params->quality);
1246                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1247                         g_print("image_util_decode_set_input_buffer failed %d\n", ret);
1248                         goto ERROR;
1249                 }
1250         } else if (params->type == IMAGE_UTIL_PNG) {
1251                 ret = image_util_encode_set_png_compression(handle, params->compression);
1252                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1253                         g_print("image_util_decode_set_input_buffer failed %d\n", ret);
1254                         goto ERROR;
1255                 }
1256         }
1257
1258         switch(menu) {
1259         case ENCODE_RUN:
1260                 if (input->image) {
1261                         SAFE_FREE(input->buffer);
1262                         ret = image_util_get_image(input->image, &input->size.w, &input->size.h, &input->color, &input->buffer, &input->buffer_size);
1263                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1264                                 g_print("image_util_get_image failed %d\n", ret);
1265                                 break;
1266                         }
1267                 }
1268
1269                 ret = image_util_encode_set_resolution(handle, input->size.w, input->size.h);
1270                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1271                         g_print("image_util_encode_set_resolution failed %d\n", ret);
1272                         break;
1273                 }
1274
1275                 ret = image_util_encode_set_colorspace(handle, input->color);
1276                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1277                         g_print("image_util_decode_run failed %d\n", ret);
1278                         break;
1279                 }
1280
1281                 ret = image_util_encode_set_input_buffer(handle, input->buffer);
1282                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1283                         g_print("image_util_encode_set_input_buffer failed %d\n", ret);
1284                         break;
1285                 }
1286
1287                 if (params->use_buffer) {
1288                         ret = image_util_encode_set_output_buffer(handle, &result->buffer);
1289                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1290                                 g_print("image_util_encode_set_output_buffer failed %d\n", ret);
1291                                 break;
1292                         }
1293                 } else {
1294                         ret = image_util_encode_set_output_path(handle, result->path);
1295                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1296                                 g_print("image_util_encode_set_output_path failed %d\n", ret);
1297                                 break;
1298                         }
1299                 }
1300
1301                 ret = image_util_encode_run(handle, &buffer_size);
1302                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1303                         g_print("image_util_encode_run failed %d\n", ret);
1304                         break;
1305                 }
1306                 result->buffer_size = buffer_size;
1307
1308                 if (params->use_buffer) {
1309                         __write_file(result->path, result->buffer, result->buffer_size);
1310                         SAFE_FREE(result->buffer);
1311                 }
1312                 break;
1313
1314         case ENCODE_RUN_ASYNC:
1315                 if (input->image) {
1316                         SAFE_FREE(input->buffer);
1317                         ret = image_util_get_image(input->image, &input->size.w, &input->size.h, &input->color, &input->buffer, &input->buffer_size);
1318                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1319                                 g_print("image_util_get_image failed %d\n", ret);
1320                                 break;
1321                         }
1322                 }
1323
1324                 ret = image_util_encode_set_resolution(handle, input->size.w, input->size.h);
1325                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1326                         g_print("image_util_encode_set_resolution failed %d\n", ret);
1327                         break;
1328                 }
1329
1330                 ret = image_util_encode_set_colorspace(handle, input->color);
1331                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1332                         g_print("image_util_decode_run failed %d\n", ret);
1333                         break;
1334                 }
1335
1336                 ret = image_util_encode_set_input_buffer(handle, input->buffer);
1337                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1338                         g_print("image_util_encode_set_input_buffer failed %d\n", ret);
1339                         break;
1340                 }
1341
1342                 if (params->use_buffer) {
1343                         ret = image_util_encode_set_output_buffer(handle, &result->buffer);
1344                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1345                                 g_print("image_util_encode_set_output_buffer failed %d\n", ret);
1346                                 break;
1347                         }
1348                 } else {
1349                         ret = image_util_encode_set_output_path(handle, result->path);
1350                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1351                                 g_print("image_util_encode_set_output_path failed %d\n", ret);
1352                                 break;
1353                         }
1354                 }
1355
1356                 ret = image_util_encode_run_async(handle, __encode_completed_cb, result);
1357                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1358                         g_print("image_util_encode_run_async failed %d\n", ret);
1359                         break;
1360                 }
1361                 __wait();
1362
1363                 if (params->use_buffer) {
1364                         __write_file(result->path, result->buffer, result->buffer_size);
1365                         SAFE_FREE(result->buffer);
1366                 }
1367                 break;
1368
1369         case ENCODE_RUN_TO_FILE:
1370                 ret = image_util_encode_run_to_file(handle, input->image, result->path);
1371                 if (ret != IMAGE_UTIL_ERROR_NONE)
1372                         g_print("image_util_encode_run_to_file failed %d\n", ret);
1373                 break;
1374         case ENCODE_RUN_TO_BUFFER:
1375                 ret = image_util_encode_run_to_buffer(handle, input->image, &result->buffer, &result->buffer_size);
1376                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1377                         g_print("image_util_encode_run_to_buffer failed %d\n", ret);
1378                         break;
1379                 }
1380                 __write_file(result->path, result->buffer, result->buffer_size);
1381                 break;
1382         case ENCODE_RUN_ASYNC_TO_FILE:
1383                 ret = image_util_encode_run_async_to_file(handle, input->image, result->path,
1384                                         __encode_to_file_completed_cb, NULL);
1385                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1386                         g_print("image_util_encode_run_async_to_file failed %d\n", ret);
1387                         break;
1388                 }
1389                 __wait();
1390                 break;
1391         case ENCODE_RUN_ASYNC_TO_BUFFER:
1392                 ret = image_util_encode_run_async_to_buffer(handle, input->image,
1393                                         __encode_to_buffer_completed_cb, result);
1394                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1395                         g_print("image_util_encode_run_async_to_buffer failed %d\n", ret);
1396                         break;
1397                 }
1398                 __wait();
1399                 __write_file(result->path, result->buffer, result->buffer_size);
1400                 break;
1401
1402         default:
1403                 g_print("wrong encode menu %u", menu);
1404                 break;
1405         }
1406
1407 ERROR:
1408         image_util_encode_destroy(handle);
1409
1410         return ret;
1411 }
1412
1413 /* encode animated GIF with deprecated APIs
1414  * input : use image_cnt & images
1415  * output : use path or buffer(buffer_size)
1416  */
1417 static int __run_encode_agif_deprecated(test_encode_menu_e menu, test_complex_data_s *input,
1418                 test_encode_agif_params_s *params, test_complex_data_s *result)
1419 {
1420         int ret = IMAGE_UTIL_ERROR_NONE;
1421         image_util_encode_h handle = NULL;
1422         unsigned int i = 0;
1423         unsigned int width = 0, height = 0;
1424         unsigned char **buffer = NULL;
1425         size_t buffer_size = 0;
1426         unsigned long long size = 0;
1427
1428         if (!input || !params || !result) {
1429                 g_print("invalid parameter!!! input: %p, params: %p, result: %p\n", input, params, result);
1430                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1431         }
1432
1433         buffer = calloc(1, sizeof(char *) * input->image_cnt);
1434         if (!buffer) {
1435                 g_print("Memory allocation failed %d\n", ret);
1436                 return IMAGE_UTIL_ERROR_OUT_OF_MEMORY;
1437         }
1438
1439         ret = image_util_encode_create(IMAGE_UTIL_GIF, &handle);
1440         if (ret != IMAGE_UTIL_ERROR_NONE) {
1441                 g_print("image_util_encode_create failed %d\n", ret);
1442                 SAFE_FREE(buffer);
1443                 return ret;
1444         }
1445
1446         for (i = 0; i < input->image_cnt; i++) {
1447                 ret = image_util_get_image(input->images[i], &width, &height, NULL, &buffer[i], &buffer_size);
1448                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1449                         g_print("image_util_get_image failed %d\n", ret);
1450                         goto ERROR;
1451                 }
1452
1453                 ret = image_util_encode_set_resolution(handle, (unsigned long) width, (unsigned long) height);
1454                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1455                         g_print("image_util_encode_set_resolution failed %d\n", ret);
1456                         goto ERROR;
1457                 }
1458
1459                 ret = image_util_encode_set_gif_frame_delay_time(handle, params->delay);
1460                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1461                         g_print("image_util_encode_set_gif_frame_delay_time failed %d\n", ret);
1462                         goto ERROR;
1463                 }
1464
1465                 ret = image_util_encode_set_input_buffer(handle, buffer[i]);
1466                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1467                         g_print("image_util_encode_set_input_buffer failed %d\n", ret);
1468                         goto ERROR;
1469                 }
1470         }
1471
1472         switch(menu) {
1473         case ENCODE_AGIF_RUN:
1474                 if (params->use_buffer) {
1475                         ret = image_util_encode_set_output_buffer(handle, &result->buffer);
1476                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1477                                 g_print("image_util_encode_set_output_buffer failed %d\n", ret);
1478                                 break;
1479                         }
1480                 } else {
1481                         ret = image_util_encode_set_output_path(handle, result->path);
1482                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1483                                 g_print("image_util_encode_set_output_path failed %d\n", ret);
1484                                 break;
1485                         }
1486                 }
1487
1488                 ret = image_util_encode_run(handle, &size);
1489                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1490                         g_print("image_util_encode_run failed %d\n", ret);
1491                         break;
1492                 }
1493
1494                 result->buffer_size = (size_t)size;
1495                 if (params->use_buffer) {
1496                         __write_file(result->path, result->buffer, result->buffer_size);
1497                         SAFE_FREE(result->buffer);
1498                 }
1499                 break;
1500
1501         case ENCODE_AGIF_RUN_ASYNC:
1502                 if (params->use_buffer) {
1503                         ret = image_util_encode_set_output_buffer(handle, &result->buffer);
1504                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1505                                 g_print("image_util_encode_set_output_buffer failed %d\n", ret);
1506                                 break;
1507                         }
1508                 } else {
1509                         ret = image_util_encode_set_output_path(handle, result->path);
1510                         if (ret != IMAGE_UTIL_ERROR_NONE) {
1511                                 g_print("image_util_encode_set_output_path failed %d\n", ret);
1512                                 break;
1513                         }
1514                 }
1515
1516                 ret = image_util_encode_run_async(handle, __encode_completed_cb, &result);
1517                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1518                         g_print("image_util_encode_run_async failed %d\n", ret);
1519                         break;
1520                 }
1521                 __wait();
1522
1523                 if (params->use_buffer) {
1524                         __write_file(result->path, result->buffer, result->buffer_size);
1525                         SAFE_FREE(result->buffer);
1526                 }
1527                 break;
1528         default:
1529                 g_print("wrong encode agif menu %u", menu);
1530                 break;
1531         }
1532
1533 ERROR:
1534         image_util_encode_destroy(handle);
1535
1536         for (i = 0; i < input->image_cnt; i++)
1537                 SAFE_FREE(buffer[i]);
1538
1539         SAFE_FREE(buffer);
1540
1541         return ret;
1542 }
1543
1544 /* encode animated GIF frame by frame
1545  * input : use image_cnt & images
1546  * output : use path or buffer(buffer_size)
1547  */
1548 static int __run_encode_agif(test_encode_menu_e menu, test_complex_data_s *input,
1549                 test_encode_agif_params_s *params, test_complex_data_s *result)
1550 {
1551         int ret = IMAGE_UTIL_ERROR_NONE;
1552         image_util_agif_encode_h handle = NULL;
1553         unsigned int i = 0;
1554
1555         if (!input || !params || !result) {
1556                 g_print("invalid parameter!!! input: %p, params: %p, result: %p\n", input, params, result);
1557                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1558         }
1559
1560         ret = image_util_agif_encode_create(&handle);
1561         if (ret != IMAGE_UTIL_ERROR_NONE) {
1562                 g_print("image_util_agif_encode_create failed %d\n", ret);
1563                 return ret;
1564         }
1565
1566         for (i = 0; i < input->image_cnt; i++) {
1567                 ret = image_util_agif_encode_add_frame(handle, input->images[i], params->delay);
1568                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1569                         g_print("image_util_agif_encode_add_frame failed %d\n", ret);
1570                         goto ERROR;
1571                 }
1572         }
1573
1574         switch(menu) {
1575         case ENCODE_AGIF_SAVE_TO_FILE:
1576                 ret = image_util_agif_encode_save_to_file(handle, result->path);
1577                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1578                         g_print("image_util_agif_encode_save_to_file failed %d\n", ret);
1579                         break;
1580                 }
1581                 break;
1582
1583         case ENCODE_AGIF_SAVE_TO_BUFFER:
1584                 ret = image_util_agif_encode_save_to_buffer(handle, &result->buffer, &result->buffer_size);
1585                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1586                         g_print("image_util_agif_encode_save_to_buffer failed %d\n", ret);
1587                         break;
1588                 }
1589                 __write_file(result->path, result->buffer, result->buffer_size);
1590                 SAFE_FREE(result->buffer);
1591                 break;
1592         default:
1593                 g_print("wrong encode agif menu %u", menu);
1594                 break;
1595         }
1596
1597 ERROR:
1598         image_util_agif_encode_destroy(handle);
1599
1600         return ret;
1601 }
1602
1603 /* run transform with parameters
1604  * input/output : use only image_h
1605  */
1606 static int __run_transform(test_transform_menu_e menu, test_complex_data_s *input,
1607                 test_transform_params_s *params, test_complex_data_s *result)
1608 {
1609         int ret = IMAGE_UTIL_ERROR_NONE;
1610         transformation_h handle = NULL;
1611         media_packet_h mpacket = NULL;
1612         media_packet_h res_mpacket = NULL;
1613
1614         if (!input || !params || !result) {
1615                 g_print("invalid parameter!!! input: %p, params: %p, result: %p\n", input, params, result);
1616                 return IMAGE_UTIL_ERROR_INVALID_PARAMETER;
1617         }
1618
1619         ret = __get_raw_data(input);
1620         if (ret != IMAGE_UTIL_ERROR_NONE) {
1621                 g_print("__get_raw_data failed %d\n", ret);
1622                 return ret;
1623         }
1624
1625         if (result->image) {
1626                 image_util_destroy_image(result->image);
1627                 result->image = NULL;
1628         }
1629
1630         ret = image_util_transform_create(&handle);
1631         if (ret != IMAGE_UTIL_ERROR_NONE) {
1632                 g_print("image_util_transform_create failed %d\n", ret);
1633                 return ret;
1634         }
1635
1636         if (params->has_convert_color) {
1637                 ret = image_util_transform_set_colorspace(handle, params->convert_color);
1638                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1639                         g_print("image_util_transform_set_colorspace failed %d\n", ret);
1640                         goto ERROR;
1641                 }
1642         }
1643
1644         if (params->has_crop) {
1645                 ret = image_util_transform_set_crop_area(handle, params->crop_area.x, params->crop_area.y, params->crop_area.w, params->crop_area.h);
1646                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1647                         g_print("image_util_transform_set_crop_area failed %d\n", ret);
1648                         goto ERROR;
1649                 }
1650         }
1651
1652         if (params->has_resize) {
1653                 ret = image_util_transform_set_resolution(handle, params->resize.w, params->resize.h);
1654                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1655                         g_print("image_util_transform_set_resolution failed %d\n", ret);
1656                         goto ERROR;
1657                 }
1658         }
1659
1660         if (params->has_rotation) {
1661                 ret = image_util_transform_set_rotation(handle, params->rotation);
1662                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1663                         g_print("image_util_transform_set_rotation failed %d\n", ret);
1664                         goto ERROR;
1665                 }
1666         }
1667
1668         switch(menu) {
1669         case TRANSFORM_RUN:
1670                 ret = _image_util_image_to_packet(input->image, &mpacket);
1671                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1672                         g_print("_image_util_image_to_packet failed %d\n", ret);
1673                         break;
1674                 }
1675
1676                 ret = image_util_transform_run(handle, mpacket, __transform_completed_cb, &res_mpacket);
1677                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1678                         g_print("image_util_transform_run failed %d\n", ret);
1679                         break;
1680                 }
1681                 __wait();
1682
1683                 ret = _image_util_packet_to_image(res_mpacket, &result->image);
1684                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1685                         g_print("_image_util_packet_to_image failed %d\n", ret);
1686                         break;
1687                 }
1688                 break;
1689         case TRANSFORM_RUN2:
1690                 ret = image_util_transform_run2(handle, input->image, &result->image);
1691                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1692                         g_print("image_util_transform_run2 failed %d\n", ret);
1693                         break;
1694                 }
1695                 break;
1696         case TRANSFORM_RUN2_ASYNC:
1697                 ret = image_util_transform_run2_async(handle, input->image, __transform_completed2_cb, result);
1698                 if (ret != IMAGE_UTIL_ERROR_NONE) {
1699                         g_print("image_util_transform_run2_async failed %d\n", ret);
1700                         break;
1701                 }
1702                 __wait();
1703                 break;
1704         default:
1705                 g_print("wrong transform menu %u\n", menu);
1706                 break;
1707         }
1708
1709 ERROR:
1710         media_packet_destroy(mpacket);
1711         media_packet_destroy(res_mpacket);
1712         image_util_transform_destroy(handle);
1713
1714         return ret;
1715 }
1716
1717 static int __run_auto(void)
1718 {
1719         int ret = IMAGE_UTIL_ERROR_NONE;
1720         image_util_type_e image_type = IMAGE_UTIL_JPEG;
1721         static test_complex_data_s encode_temp_result;
1722
1723         g_num_of_file = 0;
1724
1725         g_decode_params.color = IMAGE_UTIL_COLORSPACE_RGBA8888;
1726         g_decode_params.downscale = IMAGE_UTIL_DOWNSCALE_1_1;
1727
1728         ret = __run_decode(DECODE_RUN2, &g_input_data, &g_decode_params, &g_decode_result);
1729         if (ret == IMAGE_UTIL_ERROR_NONE)
1730                 g_print("Success DECODE_RUN2!!!\n");
1731         else
1732                 g_print("Fail DECODE_RUN2!!!\n");
1733
1734         g_encode_params.type = IMAGE_UTIL_JPEG;
1735         g_encode_params.quality = 100;
1736         __set_auto_file(g_encode_params.type, &g_encode_result.path);
1737
1738         g_transform_params.crop_area.x = 0;
1739         g_transform_params.crop_area.y = 0;
1740         g_transform_params.crop_area.w = 640;
1741         g_transform_params.crop_area.h = 480;
1742
1743         g_transform_params.resize.w = 320;
1744         g_transform_params.resize.h = 240;
1745
1746         g_transform_params.rotation = IMAGE_UTIL_ROTATION_90;
1747
1748         ret = __run_encode(ENCODE_RUN_TO_FILE, &g_decode_result, &g_encode_params, &g_encode_result);
1749         if (ret == IMAGE_UTIL_ERROR_NONE)
1750                 g_print("Success ENCODE_RUN_TO_FILE!!!\n");
1751         else
1752                 g_print("Fail ENCODE_RUN_TO_FILE!!!\n");
1753
1754         for (image_type = IMAGE_UTIL_JPEG; image_type <= IMAGE_UTIL_BMP; image_type++) {
1755                 g_print("[[[ IMAGE_TYPE %d ]]]\n", image_type);
1756
1757                 ret = __run_decode(DECODE_RUN2, &g_encode_result, &g_decode_params, &g_decode_result);
1758                 if (ret == IMAGE_UTIL_ERROR_NONE)
1759                         g_print("Success DECODE_RUN2!!!\n");
1760                 else
1761                         g_print("Fail DECODE_RUN2!!!\n");
1762
1763                 g_transform_params.has_crop = TRUE;
1764                 __run_transform(TRANSFORM_RUN2, &g_decode_result, &g_transform_params, &g_transform_result);
1765                 if (ret == IMAGE_UTIL_ERROR_NONE)
1766                         g_print("Success TRANSFORM_RUN2(crop)!!!\n");
1767                 else
1768                         g_print("Fail TRANSFORM_RUN2(crop)!!!\n");
1769
1770                 g_transform_params.has_crop = FALSE;
1771
1772                 __set_auto_file(image_type, &encode_temp_result.path);
1773                 ret = __run_encode(ENCODE_RUN_TO_FILE, &g_decode_result, &g_encode_params, &encode_temp_result);
1774                 if (ret == IMAGE_UTIL_ERROR_NONE)
1775                         g_print("Success ENCODE_RUN_TO_FILE!!!\n");
1776                 else
1777                         g_print("Fail ENCODE_RUN_TO_FILE!!!\n");
1778
1779                 __run_decode(DECODE_RUN_ASYNC2, &g_encode_result, &g_decode_params, &g_decode_result);
1780                 if (ret == IMAGE_UTIL_ERROR_NONE)
1781                         g_print("Success DECODE_RUN_ASYNC2!!!\n");
1782                 else
1783                         g_print("Fail DECODE_RUN_ASYNC2!!!\n");
1784
1785                 g_transform_params.has_resize = TRUE;
1786                 __run_transform(TRANSFORM_RUN2, &g_decode_result, &g_transform_params, &g_transform_result);
1787                 if (ret == IMAGE_UTIL_ERROR_NONE)
1788                         g_print("Success TRANSFORM_RUN2(resize)!!!\n");
1789                 else
1790                         g_print("Fail TRANSFORM_RUN2(resize)!!!\n");
1791
1792                 g_transform_params.has_resize = FALSE;
1793
1794                 __set_auto_file(image_type, &encode_temp_result.path);
1795                 ret = __run_encode(ENCODE_RUN_TO_BUFFER, &g_transform_result, &g_encode_params, &encode_temp_result);
1796                 if (ret == IMAGE_UTIL_ERROR_NONE)
1797                         g_print("Success ENCODE_RUN_TO_BUFFER!!!\n");
1798                 else
1799                         g_print("Fail ENCODE_RUN_TO_BUFFER!!!\n");
1800
1801                 __run_decode(DECODE_RUN_ASYNC2, &g_encode_result, &g_decode_params, &g_decode_result);
1802                 if (ret == IMAGE_UTIL_ERROR_NONE)
1803                         g_print("Success DECODE_RUN_ASYNC2!!!\n");
1804                 else
1805                         g_print("Fail DECODE_RUN_ASYNC2!!!\n");
1806
1807                 g_transform_params.has_rotation = TRUE;
1808                 __run_transform(TRANSFORM_RUN2, &g_decode_result, &g_transform_params, &g_transform_result);
1809                 if (ret == IMAGE_UTIL_ERROR_NONE)
1810                         g_print("Success TRANSFORM_RUN2(rotate)!!!\n");
1811                 else
1812                         g_print("Fail TRANSFORM_RUN2(rotate)!!!\n");
1813
1814                 g_transform_params.has_rotation = FALSE;
1815
1816                 /* change next image_type */
1817                 g_encode_params.type = ((image_type + 1 > IMAGE_UTIL_BMP) ? IMAGE_UTIL_BMP : (image_type + 1));
1818                 __set_auto_file(g_encode_params.type, &g_encode_result.path);
1819
1820                 ret = __run_encode(ENCODE_RUN_ASYNC_TO_BUFFER, &g_transform_result, &g_encode_params, &g_encode_result);
1821                 if (ret == IMAGE_UTIL_ERROR_NONE)
1822                         g_print("Success ENCODE_RUN_ASYNC_TO_BUFFER!!!\n");
1823                 else
1824                         g_print("Fail ENCODE_RUN_ASYNC_TO_BUFFER!!!\n");
1825         }
1826
1827         return ret;
1828 }
1829 /* test functions for testsuite */
1830
1831
1832 /* interprete menu */
1833
1834 /* push result data-set of test to stack */
1835 static void __data_push(test_complex_data_s *comp_data)
1836 {
1837         if (!comp_data)
1838                 return;
1839
1840         if (!g_queue_data) {
1841                 g_queue_data = g_queue_new();
1842                 if (!g_queue_data) {
1843                         g_print("g_queue_new failed\n");
1844                         return;
1845                 }
1846         }
1847
1848 #if DEBUG_QUEUE
1849         g_print("[push data] %u\n", comp_data->type);
1850 #endif
1851
1852         g_queue_push_tail(g_queue_data, comp_data);
1853 }
1854
1855 static void __data_push_if_empty(test_complex_data_s *comp_data)
1856 {
1857         if (g_queue_data) {
1858                 if (!g_queue_is_empty(g_queue_data)) {
1859                         g_print("data queue is not empty\n");
1860                         return ;
1861                 }
1862         }
1863
1864         __data_push(comp_data);
1865 }
1866
1867 /* pop input data-set of test from stack */
1868 static gboolean __data_pop(test_complex_data_s **comp_data)
1869 {
1870         test_complex_data_s *get = NULL;
1871
1872         if (g_queue_is_empty(g_queue_data)) {
1873                 return FALSE;
1874         }
1875
1876         get = g_queue_pop_tail(g_queue_data);
1877         if (!get) {
1878                 g_print("wrong data!\n\n");
1879                 return FALSE;
1880         }
1881
1882 #if DEBUG_QUEUE
1883         g_print("[pop data] %u\n", get->type);
1884 #endif
1885
1886         *comp_data = get;
1887
1888         return TRUE;
1889 }
1890
1891 static void __menu_move(test_menu_state_e new_menu)
1892 {
1893         test_queue_menu_s *data = NULL;
1894
1895         if (!g_queue_menu) {
1896                 g_queue_menu = g_queue_new();
1897                 if (!g_queue_menu) {
1898                         g_print("g_queue_new failed\n");
1899                         return;
1900                 }
1901         }
1902
1903         data = calloc(1, sizeof(test_queue_menu_s));
1904         if (!data) {
1905                 g_print("Memory allocation failed\n");
1906                 return;
1907         }
1908
1909 #if DEBUG_QUEUE
1910         g_print("[menu move] %u -> %u\n", g_current_menu, new_menu);
1911 #endif
1912
1913         /* push current menu into queue */
1914         data->menu_state = g_current_menu;
1915         g_queue_push_tail(g_queue_menu, data);
1916
1917         g_previous_menu = g_current_menu;
1918
1919         /* go to new menu */
1920         g_current_menu = new_menu;
1921 }
1922
1923 static void __menu_back(void)
1924 {
1925         test_queue_menu_s *data = NULL;
1926
1927         if (g_queue_is_empty(g_queue_menu)) {
1928                 g_print("empty previous menu!\n\n");
1929                 return;
1930         }
1931
1932         /* pop previous menu from queue */
1933         data = g_queue_pop_tail(g_queue_menu);
1934         if (!data) {
1935                 g_print("wrong menu data!\n\n");
1936                 return;
1937         }
1938
1939 #if DEBUG_QUEUE
1940         g_print("[menu back] %u -> %u\n", g_current_menu, data->menu_state);
1941 #endif
1942
1943         g_previous_menu = g_current_menu;
1944
1945         /* go to previous menu */
1946         g_current_menu = data->menu_state;
1947
1948         SAFE_FREE(data);
1949 }
1950
1951 static void __quit(void)
1952 {
1953         if (g_mainloop)
1954                 g_main_loop_quit(g_mainloop);
1955 }
1956
1957 static void __interpret_decode(const char *cmd, unsigned int index)
1958 {
1959         int ret = 0;
1960         test_complex_data_s *input_data = NULL;
1961
1962         switch(index) {
1963         case DECODE_SET_BUFFER:
1964                 __menu_move(SET_BUFFER_MENU);
1965                 break;
1966         case DECODE_SET_COLOR:
1967                 __menu_move(SET_COLOR_MENU);
1968                 break;
1969         case DECODE_SET_DOWNSCALE:
1970                 __menu_move(SET_DOWNSCALE_MENU);
1971                 break;
1972         case DECODE_RUN:
1973         case DECODE_RUN_ASYNC:
1974         case DECODE_RUN2:
1975         case DECODE_RUN_ASYNC2:
1976                 if (!__data_pop(&input_data)) {
1977                         g_print("There is no test data for decode.\n");
1978                         break;
1979                 }
1980                 ret = __run_decode(index, input_data, &g_decode_params, &g_decode_result);
1981                 if (ret == IMAGE_UTIL_ERROR_NONE) {
1982                         g_print("Success to decode image!!!\n");
1983 #if DUMP_RAW_IMAGE
1984                         __write_jpeg("decode", g_decode_result.image);
1985 #endif
1986                         __data_push(&g_decode_result);
1987                 } else {
1988                         g_print("Fail to decode image!!!\n");
1989                         __data_push(input_data);
1990                 }
1991                 break;
1992         default:
1993                 g_print("wrong command! %s\n\n", cmd);
1994                 break;
1995         }
1996 }
1997
1998 static void __interpret_encode(const char *cmd, unsigned int index)
1999 {
2000         int ret = 0;
2001         test_complex_data_s *input_data = NULL;
2002
2003         switch(index) {
2004         case ENCODE_SET_TYPE:
2005                 __menu_move(SET_TYPE_MENU);
2006                 break;
2007         case ENCODE_SET_QUALITY:
2008                 __menu_move(SET_QUALITY_MENU);
2009                 break;
2010         case ENCODE_SET_COMPRESIION:
2011                 __menu_move(SET_COMPRESSION_MENU);
2012                 break;
2013         case ENCODE_SET_TO_BUFFER:
2014                 __menu_move(SET_TO_BUFFER_MENU);
2015                 break;
2016         case ENCODE_RUN:
2017         case ENCODE_RUN_ASYNC:
2018         case ENCODE_RUN_TO_FILE:
2019         case ENCODE_RUN_TO_BUFFER:
2020         case ENCODE_RUN_ASYNC_TO_FILE:
2021         case ENCODE_RUN_ASYNC_TO_BUFFER:
2022                 if (!__data_pop(&input_data)) {
2023                         g_print("There is no test data for encode.\n");
2024                         break;
2025                 }
2026                 __set_encode_file(g_encode_params.type, FILE_FOR_ENCODE, &g_encode_result.path);
2027                 ret = __run_encode(index, input_data, &g_encode_params, &g_encode_result);
2028                 if (ret == IMAGE_UTIL_ERROR_NONE) {
2029                         g_print("Success to encode image!!!\n");
2030                         __data_push(&g_encode_result);
2031                 } else {
2032                         g_print("Fail to encode image!!!\n");
2033                         __data_push(input_data);
2034                 }
2035                 break;
2036         default:
2037                 g_print("wrong command! %s\n\n", cmd);
2038                 break;
2039         }
2040 }
2041
2042 static void __interpret_encode_agif(const char *cmd, unsigned int index)
2043 {
2044         int ret = 0;
2045         test_complex_data_s *input_data = NULL;
2046
2047         switch(index) {
2048         case ENCODE_AGIF_SET_DIR:
2049                 __menu_move(SET_DIR_MENU);
2050                 break;
2051         case ENCODE_AGIF_SET_DELAY:
2052                 __menu_move(SET_DELAY_MENU);
2053                 break;
2054         case ENCODE_AGIF_SET_TO_BUFFER:
2055                 __menu_move(SET_TO_BUFFER_MENU);
2056                 break;
2057         case ENCODE_AGIF_RUN:
2058         case ENCODE_AGIF_RUN_ASYNC:
2059                 if (!__data_pop(&input_data)) {
2060                         g_print("There is no test data for decode.\n");
2061                         break;
2062                 }
2063                 __set_encode_file(IMAGE_UTIL_GIF, FILE_FOR_ENCODE_AGIF, &g_encode_agif_result.path);
2064                 ret = __run_encode_agif_deprecated(index, input_data, &g_encode_agif_params, &g_encode_agif_result);
2065                 if (ret == IMAGE_UTIL_ERROR_NONE) {
2066                         g_print("Success to encode image!!!\n");
2067                         __data_push(&g_encode_agif_result);
2068                 } else {
2069                         g_print("Fail to encode image!!!\n");
2070                         __data_push(input_data);
2071                 }
2072                 break;
2073         case ENCODE_AGIF_SAVE_TO_FILE:
2074         case ENCODE_AGIF_SAVE_TO_BUFFER:
2075                 if (!__data_pop(&input_data)) {
2076                         g_print("There is no test data for decode.\n");
2077                         break;
2078                 }
2079                 __set_encode_file(IMAGE_UTIL_GIF, FILE_FOR_ENCODE_AGIF, &g_encode_agif_result.path);
2080                 ret = __run_encode_agif(index, input_data, &g_encode_agif_params, &g_encode_agif_result);
2081                 if (ret == IMAGE_UTIL_ERROR_NONE) {
2082                         g_print("Success to encode image!!!\n");
2083                         __data_push(&g_encode_agif_result);
2084                 } else {
2085                         g_print("Fail to encode image!!!\n");
2086                         __data_push(input_data);
2087                 }
2088                 break;
2089         default:
2090                 g_print("wrong command! %s\n\n", cmd);
2091                 break;
2092         }
2093 }
2094
2095 static void __interpret_transform(const char *cmd, unsigned int index)
2096 {
2097         int ret = 0;
2098         test_complex_data_s *input_data = NULL;
2099
2100         switch(index) {
2101         case TRANSFORM_SET_CONVERT:
2102                 __menu_move(SET_CONVERT_MENU);
2103                 break;
2104         case TRANSFORM_SET_CROP:
2105                 __menu_move(SET_CROP_MENU);
2106                 break;
2107         case TRANSFORM_SET_RESIZE:
2108                 __menu_move(SET_RESIZE_MENU);
2109                 break;
2110         case TRANSFORM_SET_ROTATE:
2111                 __menu_move(SET_ROTATE_MENU);
2112                 break;
2113         case TRANSFORM_RUN:
2114         case TRANSFORM_RUN2:
2115         case TRANSFORM_RUN2_ASYNC:
2116                 if (!__data_pop(&input_data)) {
2117                         g_print("There is no test data for decode.\n");
2118                         break;
2119                 }
2120                 ret = __run_transform(index, input_data, &g_transform_params, &g_transform_result);
2121                 if (ret == IMAGE_UTIL_ERROR_NONE) {
2122                         g_print("Success to transform image!!!\n");
2123 #if DUMP_RAW_IMAGE
2124                         __write_jpeg("transform", g_transform_result.image);
2125 #endif
2126                         __data_push(&g_transform_result);
2127                 } else {
2128                         g_print("Fail to transform image!!!\n");
2129                         __data_push(input_data);
2130                 }
2131                 break;
2132         default:
2133                 g_print("wrong command! %s\n\n", cmd);
2134                 break;
2135         }
2136 }
2137
2138 static gboolean __interpret_set_menu(test_menu_state_e menu_state, const char *cmd, unsigned int index)
2139 {
2140         switch(menu_state) {
2141         case SET_BUFFER_MENU:
2142                 if (g_ascii_strcasecmp(cmd, "y") == 0) {
2143                         SAFE_FREE(g_input_data.buffer);
2144                         if (__read_file(g_input_data.path, (void **)&g_input_data.buffer, &g_input_data.buffer_size)) {
2145                                 g_input_data.has_buffer = TRUE;
2146                                 g_print("Success to read file(%s), read_size(%zu)\n", g_input_data.path, g_input_data.buffer_size);
2147                         }
2148                 }
2149                 break;
2150         case SET_TO_BUFFER_MENU:
2151                 if (g_ascii_strcasecmp(cmd, "y") == 0) {
2152                         if (g_previous_menu == ENCODE_MENU) {
2153                                 g_encode_params.use_buffer = TRUE;
2154                                 g_print("Data will be encoded to buffer\n");
2155                         } else if (g_previous_menu == ENCODE_AGIF_MENU) {
2156                                 g_encode_agif_params.use_buffer = TRUE;
2157                                 g_print("Data will be encoded to buffer\n");
2158                         }
2159                 } else {
2160                         g_encode_params.use_buffer = FALSE;
2161                         g_encode_agif_params.use_buffer = FALSE;
2162                 }
2163                 break;
2164         case SET_RAW_COLOR_MENU:
2165                 g_input_data.color = index;
2166                 g_print("Success to set raw path color (%u)\n", g_input_data.color);
2167                 break;
2168         case SET_COLOR_MENU:
2169                 g_decode_params.color = index;
2170                 g_print("Success to set color (%u)\n", g_decode_params.color);
2171                 break;
2172         case SET_COMPRESSION_MENU:
2173                 g_encode_params.compression = index;
2174                 g_print("Success to set compression (%u)\n", g_encode_params.compression);
2175                 break;
2176         case SET_CONVERT_MENU:
2177                 g_transform_params.convert_color = index;
2178                 g_transform_params.has_convert_color = TRUE;
2179                 g_print("Success to set convert_color (%u)\n", g_transform_params.convert_color);
2180                 break;
2181         case SET_CROP_MENU:
2182                 if (!__set_input_crop_area(cmd, &g_transform_params.crop_area)) {
2183                         g_print("wrong size! %s\n\n", cmd);
2184                         return FALSE;
2185                 }
2186                 g_transform_params.has_crop = TRUE;
2187                 g_print("Success to set crop_area(%ux%u, %ux%u)\n", g_transform_params.crop_area.x,
2188                                 g_transform_params.crop_area.y, g_transform_params.crop_area.w, g_transform_params.crop_area.h);
2189                 break;
2190         case SET_DELAY_MENU:
2191                 g_encode_agif_params.delay = index;
2192                 g_print("Success to set agif delay (%u)\n", g_encode_agif_params.delay);
2193                 break;
2194         case SET_DOWNSCALE_MENU:
2195                 g_decode_params.downscale = index;
2196                 break;
2197         case SET_QUALITY_MENU:
2198                 g_encode_params.quality = index;
2199                 g_print("Success to set quality (%u)\n", g_encode_params.quality);
2200                 break;
2201         case SET_RESIZE_MENU:
2202                 if (!__set_input_size(cmd, &g_transform_params.resize)) {
2203                         g_print("wrong size! %s\n\n", cmd);
2204                         return FALSE;
2205                 }
2206                 g_transform_params.has_resize = TRUE;
2207                 g_print("Success to set resize (%ux%u)\n", g_transform_params.resize.w, g_transform_params.resize.h);
2208                 break;
2209         case SET_ROTATE_MENU:
2210                 g_transform_params.rotation = index;
2211                 g_transform_params.has_rotation = TRUE;
2212                 g_print("Success to set rotate (%u)\n", g_transform_params.rotation);
2213                 break;
2214         case SET_SIZE_MENU:
2215                 if (!__set_input_size(cmd, &g_input_data.size)) {
2216                         g_print("wrong size! %s\n\n", cmd);
2217                         return FALSE;
2218                 }
2219                 g_print("Success to set size (%ux%u)\n", g_input_data.size.w, g_input_data.size.h);
2220                 break;
2221         case SET_TYPE_MENU:
2222                 g_encode_params.type = index;
2223                 __set_encode_file(g_encode_params.type, FILE_FOR_ENCODE, &g_encode_result.path);
2224                 g_print("Success to set image_type (%u)\n", g_encode_params.type);
2225                 break;
2226         default:
2227                 g_print("wrong command! %s\n\n", cmd);
2228                 return FALSE;
2229         }
2230
2231         return TRUE;
2232 }
2233
2234 static void __interpret_main(const char *cmd, unsigned int index)
2235 {
2236         __data_push_if_empty(&g_input_data);
2237
2238         switch(index) {
2239         case SET_PATH:
2240                 __menu_move(SET_PATH_MENU);
2241                 break;
2242         case TEST_AUTO:
2243                 __run_auto();
2244                 break;
2245         case TEST_DECODE:
2246                 __menu_move(DECODE_MENU);
2247                 break;
2248         case TEST_ENCODE:
2249                 __menu_move(ENCODE_MENU);
2250                 break;
2251         case TEST_ENCODE_AGIF:
2252                 __menu_move(ENCODE_AGIF_MENU);
2253                 break;
2254         case TEST_TRANSFORM:
2255                 __menu_move(TRANSFORM_MENU);
2256                 break;
2257         default:
2258                 g_print("wrong command! %s\n\n", cmd);
2259                 break;
2260         }
2261 }
2262
2263 static void __interpret_cmd(char *cmd)
2264 {
2265         unsigned int index = 0;
2266
2267         if (cmd == NULL || strlen(cmd) == 0) {
2268                 g_print("No input!\n");
2269                 return;
2270         }
2271
2272         if (strncmp(cmd, "q", strlen(cmd)) == 0) {
2273                 __quit();
2274                 return;
2275         }
2276
2277         if (strncmp(cmd, "b", strlen(cmd)) == 0) {
2278                 __menu_back();
2279                 __display_menu(g_current_menu);
2280                 return;
2281         }
2282
2283         if (__safe_atoui(cmd, &index))
2284                 g_print("number input! %u\n", index);
2285         else
2286                 g_print("string input! %s\n", cmd);
2287
2288         switch(g_current_menu) {
2289         /* Main menu */
2290         case MAIN_MENU:
2291                 __interpret_main(cmd, index);
2292                 break;
2293
2294         /* Decode menu */
2295         case DECODE_MENU:
2296                 __interpret_decode(cmd, index);
2297                 break;
2298
2299         /* Encode menu */
2300         case ENCODE_MENU:
2301                 __interpret_encode(cmd, index);
2302                 break;
2303
2304         /* Encode A-GIF menu */
2305         case ENCODE_AGIF_MENU:
2306                 __interpret_encode_agif(cmd, index);
2307                 break;
2308
2309         /* Transform menu */
2310         case TRANSFORM_MENU:
2311                 __interpret_transform(cmd, index);
2312                 break;
2313
2314         /* Set path menu */
2315         case SET_PATH_MENU:
2316                 if (!__set_input_path(cmd)) {
2317                         g_print("[Warn] Fail to set input path! %s\n", cmd);
2318                         __menu_back();
2319                         break;
2320                 }
2321                 __menu_back();
2322                 if (IS_RAW_FILE(g_input_data.path)) {
2323                         g_input_data.is_raw = TRUE;
2324                         __menu_move(SET_PATH_SUB_MENU);
2325                 }
2326                 break;
2327         case SET_PATH_SUB_MENU:
2328                 switch(index) {
2329                 case RAW_IMG_SET_COLOR:
2330                         __menu_move(SET_RAW_COLOR_MENU);
2331                         break;
2332                 case RAW_IMG_SET_SIZE:
2333                         __menu_move(SET_SIZE_MENU);
2334                         break;
2335                 default:
2336                         g_print("wrong raw path menu! %s\n\n", cmd);
2337                         break;
2338                 }
2339                 break;
2340         case SET_DIR_MENU:
2341                 if (!__set_input_path(cmd)) {
2342                         g_print("[Warn] Fail to set input path! %s\n", cmd);
2343                         break;
2344                 }
2345                 __menu_back();
2346                 break;
2347
2348         /* Set optional parameters menu */
2349         case SET_BUFFER_MENU:
2350         case SET_TO_BUFFER_MENU:
2351         case SET_COLOR_MENU:
2352         case SET_RAW_COLOR_MENU:
2353         case SET_COMPRESSION_MENU:
2354         case SET_CONVERT_MENU:
2355         case SET_CROP_MENU:
2356         case SET_DELAY_MENU:
2357         case SET_DOWNSCALE_MENU:
2358         case SET_QUALITY_MENU:
2359         case SET_RESIZE_MENU:
2360         case SET_ROTATE_MENU:
2361         case SET_SIZE_MENU:
2362         case SET_TYPE_MENU:
2363                 if (__interpret_set_menu(g_current_menu, cmd, index))
2364                         __menu_back();
2365                 break;
2366
2367         default:
2368                 g_print("wrong menu state\n");
2369                 break;
2370         }
2371
2372         __display_menu(g_current_menu);
2373         return;
2374 }
2375 /* interprete menu */
2376
2377
2378 /* testsuite mainloop */
2379 /*
2380  * This function initializes and sets default values for testsuite
2381  */
2382 static void _init_data(void)
2383 {
2384         memset(&g_input_data, 0, sizeof(test_complex_data_s));
2385
2386         /* init & set default parameters */
2387         memset(&g_decode_params, 0, sizeof(test_decode_params_s));
2388         memset(&g_encode_params, 0, sizeof(test_encode_params_s));
2389         memset(&g_encode_agif_params, 0, sizeof(test_encode_agif_params_s));
2390         memset(&g_transform_params, 0, sizeof(test_transform_params_s));
2391
2392         /* If you want to change default value, change the value here!!! */
2393         /* common */
2394
2395         /* decode */
2396         g_decode_params.color = IMAGE_UTIL_COLORSPACE_RGBA8888;
2397         g_decode_params.downscale = IMAGE_UTIL_DOWNSCALE_1_1;
2398
2399         /* encode */
2400         g_encode_params.type = IMAGE_UTIL_JPEG;
2401         g_encode_params.quality = 75;
2402         g_encode_params.compression = IMAGE_UTIL_PNG_COMPRESSION_6;
2403
2404         /* encode_agif */
2405         g_encode_agif_params.delay = 10;
2406
2407         /* transform, not used yet */
2408         g_transform_params.convert_color = IMAGE_UTIL_COLORSPACE_RGB888;
2409         g_transform_params.crop_area.x = g_transform_params.crop_area.y = 100;
2410         g_transform_params.crop_area.w = g_transform_params.crop_area.h = 200;
2411         g_transform_params.resize.x = g_transform_params.resize.y = 0;
2412         g_transform_params.resize.w = g_transform_params.resize.h = 100;
2413         g_transform_params.rotation = IMAGE_UTIL_ROTATION_90;
2414
2415         /* init results */
2416         memset(&g_decode_result, 0, sizeof(test_complex_data_s));
2417         memset(&g_encode_result, 0, sizeof(test_complex_data_s));
2418         memset(&g_transform_result, 0, sizeof(test_complex_data_s));
2419 }
2420
2421 /*
2422  * This function releases allocated memory for testsuite when program finish
2423  */
2424 static void _destroy_data(void)
2425 {
2426         unsigned int i = 0;
2427
2428         g_queue_free_full(g_queue_menu, __queue_free_func);
2429         g_queue_free_full(g_queue_agif_images, __queue_free_func);
2430
2431         SAFE_G_FREE(g_input_data.path);
2432         SAFE_FREE(g_input_data.buffer);
2433
2434         for (i = 0; i < g_input_data.image_cnt; i++)
2435                 image_util_destroy_image(g_input_data.images[i]);
2436
2437         SAFE_FREE(g_decode_result.buffer);
2438         SAFE_FREE(g_transform_result.buffer);
2439         SAFE_FREE(g_encode_result.buffer);
2440
2441         image_util_destroy_image(g_decode_result.image);
2442         image_util_destroy_image(g_transform_result.image);
2443         image_util_destroy_image(g_encode_result.image);
2444 }
2445
2446 /*
2447  * This function gets input
2448  */
2449 static gboolean _input_func(GIOChannel *channel, GIOCondition condition, gpointer data)
2450 {
2451         gchar buf[MAX_STRING_LEN];
2452         gsize read = 0;
2453         GIOStatus status = 0;
2454         GError *error = NULL;
2455
2456         status = g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
2457         if (!status) {
2458                 g_print("g_io_channel_read_chars failed : %s", error ? error->message : "none");
2459                 if (error) g_error_free(error);
2460                 return TRUE;
2461         }
2462
2463         buf[read] = '\0';
2464         g_strstrip(buf);
2465
2466         __interpret_cmd(buf);
2467
2468         return TRUE;
2469 }
2470
2471 /*
2472  * This function displays help
2473  */
2474 static void _display_help(const char *cmd)
2475 {
2476         g_print("====================================================\n");
2477         g_print("[image-util CAPI test: v%s\n", VERSION);
2478         g_print("%s {file_path} {test_mode} [for jpg/png/gif/bmp]\n", cmd);
2479         g_print("%s {directory} {test_mode} [for a-gif]\n", cmd);
2480         g_print("{test_mode} 0:auto, 1:decode, 2:encode, 3:a-gif, 4:transform\n");
2481         g_print("\n[Note]\n");
2482         g_print("  The {file_path}/{directory} are mandotary. but the {test_mode} is optional.\n");
2483         g_print("\n[usage]\n");
2484         g_print("  1. %s test.jpg\n", cmd);
2485         g_print("  2. %s test.jpg %d\n", cmd, TEST_AUTO);
2486         g_print("  3. %s test_dir %d\n", cmd, TEST_ENCODE_AGIF);
2487         g_print("====================================================\n");
2488 }
2489
2490 /*
2491  * Main
2492  */
2493 int main(int argc, char **argv)
2494 {
2495         GIOChannel *stdin_channel = NULL;
2496         stdin_channel = g_io_channel_unix_new(0);
2497         g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
2498         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)_input_func, NULL);
2499
2500         _init_data();
2501
2502         if (argc > 1 && argv[1]) {
2503                 if ((strcmp(argv[1], "help") == 0)
2504                         || (strcmp(argv[1], "-h") == 0)
2505                         || (strcmp(argv[1], "-help") == 0)
2506                         || (strcmp(argv[1], "--help") == 0)) {
2507                         _display_help(argv[0]);
2508                         return 0;
2509                 }
2510
2511                 __set_input_path(argv[1]);
2512         }
2513
2514         /*
2515          * if there is no argument for path, go to set path menu.
2516          * else if there is raw data image, go to set path sub menu.
2517          */
2518         if (!g_input_data.path) {
2519                 __menu_move(MAIN_MENU);
2520                 __menu_move(SET_PATH_MENU);
2521         } else if (IS_RAW_FILE(g_input_data.path)) {
2522                 g_input_data.is_raw = TRUE;
2523                 __menu_move(MAIN_MENU);
2524                 __menu_move(SET_PATH_SUB_MENU);
2525         }
2526
2527         if (argc > 2) {
2528                 __menu_move(MAIN_MENU);
2529                 __interpret_cmd(argv[2]);
2530         } else {
2531                 __display_menu(g_current_menu);
2532         }
2533
2534         g_mainloop = g_main_loop_new(NULL, FALSE);
2535
2536         g_main_loop_run(g_mainloop);
2537         g_main_loop_unref(g_mainloop);
2538
2539         _destroy_data();
2540
2541         g_io_channel_unref(stdin_channel);
2542
2543         return 0;
2544 }