gif/test/mm_util_gif_testsuite.c

   1 /*
   2  * libmm-utility
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Vineeth T M <vineeth.tm@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <limits.h>
  27 #include <mm_util_gif.h>
  28 #include <tzplatform_config.h>
  29
  30 #define ENCODE_RESULT_PATH tzplatform_mkpath(TZ_USER_CONTENT, "encode_test.gif")
  31 #define ANIMATED_FRAME_MAX      100
  32
  33 static gboolean g_encode_mem = FALSE;
  34
  35 typedef struct {
  36         char file_name[PATH_MAX];
  37         mm_util_gif_data decoded;
  38 } gif_test_data_s;
  39
  40
  41 static int _write_file(const char *file_name, void *data, size_t data_size)
  42 {
  43         FILE *fp = NULL;
  44
  45         fprintf(stderr, "\tdata %s %p size:%zu\n", file_name, data, data_size);
  46
  47         if (!file_name || !data || data_size == 0) {
  48                 fprintf(stderr, "\tinvalid data %s %p size:%zu\n", file_name, data, data_size);
  49                 return FALSE;
  50         }
  51
  52         fprintf(stderr, "\tTry to open %s to write\n", file_name);
  53
  54         fp = fopen(file_name, "w");
  55         if (fp == NULL) {
  56                 fprintf(stderr, "\tfile open failed %d\n", errno);
  57                 return FALSE;
  58         }
  59
  60         fwrite(data, 1, data_size, fp);
  61         fclose(fp);
  62         fp = NULL;
  63
  64         fprintf(stderr, "\tfile [%s] write DONE\n", file_name);
  65
  66         return TRUE;
  67 }
  68
  69 static inline void flush_stdin()
  70 {
  71         int ch;
  72         while ((ch = getchar()) != EOF && ch != '\n') ;
  73 }
  74
  75 int main(int argc, char *argv[])
  76 {
  77         int ret = 0;
  78         int i = 0, nfiles = 0;
  79         gif_test_data_s files[ANIMATED_FRAME_MAX];
  80
  81         if (argc < 2) {
  82                 fprintf(stderr, "\t[usage]\n");
  83                 fprintf(stderr, "\t\t1. decode : %s decode filepath\n", argv[0]);
  84                 fprintf(stderr, "\t\t2. encode-agif/encode-mem-agif : %s encode-agif dirpath\n", argv[0]);
  85                 return 0;
  86         }
  87
  88         if (!strcmp("decode", argv[1])) {
  89                 size_t nbytes = g_strlcpy(files[nfiles].file_name, argv[2], sizeof(files[nfiles].file_name));
  90                 if (nbytes != strlen(argv[2])) {
  91                         fprintf(stderr, "\tERROR is occurred %x\n", ret);
  92                         return 0;
  93                 }
  94                 nfiles++;
  95         } else if (!strcmp("encode-agif", argv[1]) || !strcmp("encode-mem-agif", argv[1])) {
  96                 if (!strcmp("encode-mem-agif", argv[1]))
  97                         g_encode_mem = TRUE;
  98
  99                 fprintf(stderr, "\tencode-agif %s\n", argv[1]);
 100                 struct dirent *dp = NULL;
 101                 DIR *fd = opendir(argv[2]);
 102                 int j = 0;
 103                 if (fd == NULL) {
 104                         fprintf(stderr, "\tlistdir: can't open %s\n", argv[2]);
 105                         return 0;
 106                 }
 107
 108                 while ((dp = readdir(fd)) != NULL) {
 109                         if (strlen(dp->d_name) == 0)
 110                                 continue;
 111                         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
 112                                 continue;       /* skip self and parent */
 113                         size_t nbytes = g_snprintf(files[nfiles].file_name, sizeof(files[nfiles].file_name), "%s%s", argv[2], dp->d_name);
 114                         if (nbytes == 0)
 115                                 continue;
 116                         nfiles++;
 117                 }
 118                 closedir(fd);
 119
 120                 /* sort file name */
 121                 char temp[PATH_MAX];
 122                 for (i = 0; i < nfiles; i++) {
 123                         for (j = 0; j < nfiles - 1; j++) {
 124                                 if ((strlen(files[j].file_name) > strlen(files[j + 1].file_name)) ||
 125                                         (strcmp(files[j].file_name, files[j + 1].file_name) > 0 && strlen(files[j].file_name) == strlen(files[j + 1].file_name))) {
 126                                         memset(temp, 0, PATH_MAX);
 127                                         g_strlcpy(temp, files[j].file_name, sizeof(temp));
 128                                         g_strlcpy(files[j].file_name, files[j + 1].file_name, sizeof(files[j].file_name));
 129                                         g_strlcpy(files[j + 1].file_name, temp, sizeof(files[j + 1].file_name));
 130                                 }
 131                         }
 132                 }
 133         } else {
 134                 fprintf(stderr, "\tunknown command [%s]\n", argv[1]);
 135                 return 0;
 136         }
 137
 138         fprintf(stderr, "\tnfiles: %d\n", nfiles);
 139
 140         for (i = 0; i < nfiles && i < ANIMATED_FRAME_MAX; i++) {
 141                 fprintf(stderr, "\tdecode %s\n", files[i].file_name);
 142                 ret = mm_util_decode_from_gif_file(&files[i].decoded, files[i].file_name);
 143                 if (ret != MM_UTIL_ERROR_NONE) {
 144                         fprintf(stderr, "\tERROR is occurred %x to decode %s\n", ret, files[i].file_name);
 145                         continue;
 146                 }
 147         }
 148
 149         mm_gif_file_h gif_file = NULL;
 150         mm_gif_image_h gif_image = NULL;
 151         unsigned char *encoded_gif_mem = NULL;
 152         unsigned long encoded_gif_size = 0;
 153
 154         ret = mm_util_gif_encode_create(&gif_file);
 155         fprintf(stderr, "\t mm_util_gif_enc_create [%d]\n", ret);
 156         if (g_encode_mem) {
 157                 ret = mm_util_gif_encode_set_mem(gif_file, (void **)&encoded_gif_mem, &encoded_gif_size);
 158                 fprintf(stderr, "\t mm_util_gif_encode_set_mem [%d]\n", ret);
 159         } else {
 160                 ret = mm_util_gif_encode_set_file(gif_file, ENCODE_RESULT_PATH);
 161                 fprintf(stderr, "\t mm_util_gif_enc_set_file [%d]\n", ret);
 162         }
 163
 164         ret = mm_util_gif_encode_set_repeat(gif_file, FALSE, 0);
 165         fprintf(stderr, "\t mm_util_gif_encode_set_repeat [%d]\n", ret);
 166
 167         ret = mm_util_gif_encode_set_resolution(gif_file, files[0].decoded.width, files[0].decoded.height);
 168         fprintf(stderr, "\t mm_util_gif_enc_set_resolution [%d]\n", ret);
 169         /* repeat */
 170         for (i = 0; i < nfiles; i++) {
 171                 if (files[i].decoded.data) {
 172                         ret = mm_util_gif_image_create(gif_file, &gif_image);
 173                         fprintf(stderr, "\t mm_util_gif_image_create [%d]\n", ret);
 174
 175                         ret = mm_util_gif_image_set_image(gif_image, files[i].decoded.data);
 176                         fprintf(stderr, "\t mm_util_gif_image_set_image [%d]\n", ret);
 177
 178                         ret = mm_util_gif_image_set_delay_time(gif_image, 20);
 179                         fprintf(stderr, "\t mm_util_gif_image_set_delay_time [%d]\n", ret);
 180
 181                         ret = mm_util_gif_image_set_position(gif_image, 0, 0, files[i].decoded.width, files[i].decoded.height);
 182                         fprintf(stderr, "\t mm_util_gif_image_set_position [%d]\n", ret);
 183
 184                         ret = mm_util_gif_image_set_disposal_mode(gif_image, MM_UTIL_GIF_DISPOSAL_UNSPECIFIED);
 185                         fprintf(stderr, "\t mm_util_gif_image_set_disposal_mode [%d]\n", ret);
 186
 187                         ret = mm_util_gif_encode_add_image(gif_file, gif_image);
 188                         fprintf(stderr, "\t mm_util_gif_enc_add_image [%d]\n", ret);
 189
 190                         mm_util_gif_image_destory(gif_image);
 191                         free(files[i].decoded.data);
 192                 }
 193         }
 194         /* repeat */
 195         ret = mm_util_gif_encode_save(gif_file);
 196         fprintf(stderr, "\t mm_util_gif_enc_save [%d]\n", ret);
 197         if (g_encode_mem)
 198                 _write_file(ENCODE_RESULT_PATH, (void *)encoded_gif_mem, (size_t)encoded_gif_size);
 199         mm_util_gif_encode_destroy(gif_file);
 200
 201         return 0;
 202 }