jxl/test/mm_util_jxl_testsuite.c

   1 /*
   2 * Copyright (c) 2022 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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <glib.h>
  21
  22 #include <mm_util_jxl.h>
  23 #include <mm_util_jpeg.h>
  24 #include <mm_util_private.h>
  25 #include <mm_util_test_internal.h>
  26
  27 #define MAX_QUALITY                     4
  28
  29 static char *MODE_TO_STR[] = {
  30         "AUTO",
  31         "DECODE_FILE",
  32         "DECODE_BUFFER",
  33         "ENCODE_FILE",
  34         "ENCODE_BUFFER",
  35         "",
  36 };
  37
  38 /* for arguments */
  39 static unsigned int g_test_mode = 0;
  40 static char *g_path = NULL;
  41 static unsigned int g_width = 0;
  42 static unsigned int g_height = 0;
  43 static unsigned int g_color = MM_UTIL_COLOR_RGB24;
  44 static bool g_lossless = false;
  45
  46 /* for reading file */
  47 static void *g_read_data = NULL;
  48 static gsize g_read_size = 0;
  49
  50 /* for saving result */
  51 static const char *g_test_filename[TEST_NUM][MM_UTIL_COLOR_NUM] = {
  52         [TEST_DECODE_FILE] = {
  53                 [MM_UTIL_COLOR_RGB24] = "/opt/usr/home/owner/media/test_jxl_file_rgb24.jpg",
  54                 [MM_UTIL_COLOR_RGBA] = "/opt/usr/home/owner/media/test_jxl_file_rgba.jpg",
  55         },
  56         [TEST_DECODE_BUFFER] = {
  57                 [MM_UTIL_COLOR_RGB24] = "/opt/usr/home/owner/media/test_jxl_buff_rgb24.jpg",
  58                 [MM_UTIL_COLOR_RGBA] = "/opt/usr/home/owner/media/test_jxl_buff_rgba.jpg",
  59         },
  60         [TEST_ENCODE_FILE] = {
  61                 [MM_UTIL_COLOR_RGB24] = "/opt/usr/home/owner/media/test_jxl_file_rgb24.jxl",
  62                 [MM_UTIL_COLOR_RGBA] = "/opt/usr/home/owner/media/test_jxl_file_rgba.jxl",
  63         },
  64         [TEST_ENCODE_BUFFER] = {
  65                 [MM_UTIL_COLOR_RGB24] = "/opt/usr/home/owner/media/test_jxl_buff_rgb24.jxl",
  66                 [MM_UTIL_COLOR_RGBA] = "/opt/usr/home/owner/media/test_jxl_buff_rgba.jxl",
  67         },
  68 };
  69
  70 static mm_util_image_h g_decoded_data = NULL;
  71 static mm_util_enc_opt_h g_enc_opt = NULL;
  72
  73 static void __print_help(const char *argv0)
  74 {
  75         g_print("\t[usage]\n");
  76         g_print("\t\t1. decode : %s mode path color_format(opt.) lossless(opt.)\n", argv0);
  77         g_print("\t\t2. mode : %d - auto, %d - decode from file, %d - decode from buffer, %d - encode to file, %d - encode to buffer\n",
  78                         TEST_AUTO, TEST_DECODE_FILE, TEST_DECODE_BUFFER, TEST_ENCODE_FILE, TEST_ENCODE_BUFFER);
  79         g_print("\t\t\t e.g. %s %d test.jxl\n", argv0, TEST_AUTO);
  80         g_print("\t\t\t e.g. %s %d test.jxl 7\n", argv0, TEST_DECODE_FILE);
  81         g_print("\t\t\t e.g. %s %d test.jxl 1920 1280 7\n", argv0, TEST_ENCODE_FILE);
  82 }
  83
  84 static gboolean __get_arguments(int argc, char *argv[])
  85 {
  86         unsigned int lossless = 0;
  87
  88         if (!mm_util_safe_str_to_valid_uint(argv[1], TEST_AUTO, TEST_NUM - 1, &g_test_mode)) {
  89                 g_print("\t[JXL_testsuite] wrong mode(%s) for test\n", argv[1]);
  90                 __print_help(argv[0]);
  91                 return FALSE;
  92         }
  93
  94         g_path = g_strdup(argv[2]);
  95
  96         if (g_test_mode == TEST_AUTO) {
  97                 // optional : lossless
  98                 if (!mm_util_safe_str_to_valid_uint(argv[3], 0, 1, &lossless))
  99                         g_print("\t[JXL_testsuite] lossless is default(%d)\n", g_lossless);
 100                 else
 101                         g_lossless = (lossless == 1) ? true : false;
 102         } else if ((g_test_mode == TEST_DECODE_FILE) || (g_test_mode == TEST_DECODE_BUFFER)) {
 103                 if (!mm_util_safe_str_to_valid_uint(argv[3], MM_UTIL_COLOR_YUV420, MM_UTIL_COLOR_NUM - 1, &g_color))
 104                         g_print("\t[JXL_testsuite] color is default(%d)\n", g_color);
 105         } else if (g_test_mode == TEST_ENCODE_FILE || g_test_mode == TEST_ENCODE_BUFFER) {
 106                 if (argc < 5) {
 107                         g_print("\t[JPEG_testsuite] not enough args\n");
 108                         __print_help(argv[0]);
 109                         return FALSE;
 110                 }
 111
 112                 if (!mm_util_safe_str_to_uint(argv[3], &g_width)) {
 113                         g_print("\t[JXL_testsuite] wrong width %s\n", argv[3]);
 114                         return FALSE;
 115                 }
 116
 117                 if (!mm_util_safe_str_to_uint(argv[4], &g_height)) {
 118                         g_print("\t[JXL_testsuite] wrong height %s\n", argv[4]);
 119                         return FALSE;
 120                 }
 121
 122                 if (!mm_util_safe_str_to_valid_uint(argv[5], 0, MM_UTIL_COLOR_NUM - 1, &g_color)) {
 123                         g_print("\t[JXL_testsuite] wrong color %s\n", argv[5]);
 124                         return FALSE;
 125                 }
 126
 127                 // optional : lossless
 128                 if (!mm_util_safe_str_to_valid_uint(argv[6], 0, 1, &lossless))
 129                         g_print("\t[JXL_testsuite] lossless is default(%d)\n", g_lossless);
 130                 else
 131                         g_lossless = (lossless == 1) ? true : false;
 132         } else {
 133                 g_print("\t[JXL_testsuite] wrong mode for test %s\n", argv[1]);
 134                 return FALSE;
 135         }
 136
 137         return TRUE;
 138 }
 139
 140 static gboolean __get_decoded_data(void)
 141 {
 142         int ret = 0;
 143
 144         ret = mm_util_file_read(g_path, &g_read_data, &g_read_size);
 145         if (ret != MM_UTIL_ERROR_NONE) {
 146                 g_print("\t[JXL_testsuite] mm_util_file_read failed : %d\n", ret);
 147                 return FALSE;
 148         }
 149         ret = mm_image_create_image(g_width, g_height, g_color,
 150                                 (const unsigned char*)g_read_data, g_read_size, &g_decoded_data);
 151         if (ret != MM_UTIL_ERROR_NONE) {
 152                 g_print("\t[JXL_testsuite] mm_image_create_image failed : %d\n", ret);
 153                 return FALSE;
 154         }
 155
 156         return TRUE;
 157 }
 158
 159 static void __set_enc_opt(bool lossless)
 160 {
 161         int ret = 0;
 162
 163         if (!g_enc_opt) {
 164                 ret = mm_util_enc_opt_create(&g_enc_opt);
 165                 if (ret != MM_UTIL_ERROR_NONE) {
 166                         g_print("\t[JXL_testsuite] mm_util_enc_opt_create failed : %d\n", ret);
 167                         return;
 168                 }
 169
 170                 ret = mm_util_enc_opt_set_codec(g_enc_opt, IMG_CODEC_JPEGXL);
 171                 if (ret != MM_UTIL_ERROR_NONE) {
 172                         g_print("\t[JXL_testsuite] mm_util_enc_opt_set_codec failed : %d\n", ret);
 173                         return;
 174                 }
 175         }
 176
 177         ret = mm_util_enc_opt_set_lossless(g_enc_opt, lossless);
 178         if (ret != MM_UTIL_ERROR_NONE) {
 179                 g_print("\t[JXL_testsuite] mm_util_enc_opt_set_lossless failed : %d\n", ret);
 180                 return;
 181         }
 182         g_print("\t[JXL_testsuite] __set_enc_opt lossless: %s\n", (lossless) ? "lossless" : "lossy");
 183 }
 184
 185 static gboolean __test_decode(const mm_util_test_mode_e mode, mm_util_color_format_e color)
 186 {
 187         int ret = 0;
 188
 189         MMUTIL_SAFE_FREE(g_read_data);
 190         MMUTIL_SAFE_IMAGE_FREE(g_decoded_data);
 191
 192         if ((mode != TEST_DECODE_FILE) && (mode != TEST_DECODE_BUFFER))
 193                 return TRUE;
 194
 195         /* test decoding jxl */
 196         if (mode == TEST_DECODE_FILE) {
 197                 ret = mm_util_decode_jxl_from_file(g_path, color, &g_decoded_data);
 198                 if (ret != MM_UTIL_ERROR_NONE) {
 199                         g_print("\t[JXL_testsuite] mm_util_decode_jxl_from_file failed %d\n", ret);
 200                         return FALSE;
 201                 }
 202         } else if (mode == TEST_DECODE_BUFFER) {
 203                 ret = mm_util_file_read(g_path, &g_read_data, &g_read_size);
 204                 if (ret != MM_UTIL_ERROR_NONE) {
 205                         g_print("\t[JXL_testsuite] mm_util_file_read failed : %d\n", ret);
 206                         return FALSE;
 207                 }
 208
 209                 ret = mm_util_decode_jxl_from_buffer(g_read_data, g_read_size, color, &g_decoded_data);
 210                 if (ret != MM_UTIL_ERROR_NONE) {
 211                         g_print("\t[JXL_testsuite] mm_util_decode_jxl_from_buffer failed %d\n", ret);
 212                         return FALSE;
 213                 }
 214         }
 215
 216         ret = mm_util_jpeg_encode_to_file(g_decoded_data, 100, g_test_filename[mode][color]);
 217         if (ret != MM_UTIL_ERROR_NONE) {
 218                 g_print("\t[JXL_testsuite] mm_util_jpeg_encode_to_file failed %d : %s\n", ret, g_test_filename[mode][color]);
 219                 return FALSE;
 220         }
 221
 222         return TRUE;
 223 }
 224
 225 static gboolean __test_encode(const mm_util_test_mode_e mode, mm_util_color_format_e color)
 226 {
 227         int ret = 0;
 228         void *encoded_data = NULL;
 229         size_t encoded_size = 0;
 230
 231         if ((mode != TEST_ENCODE_FILE) && (mode != TEST_ENCODE_BUFFER))
 232                 return TRUE;
 233
 234         /* test encoding jxl */
 235         if (mode == TEST_ENCODE_FILE) {
 236                 ret = mm_util_encode_jxl_to_file(g_decoded_data, g_enc_opt, g_test_filename[mode][color]);
 237                 if (ret != MM_UTIL_ERROR_NONE) {
 238                         g_print("\t[JXL_testsuite] mm_util_encode_jxl_to_file failed : %d\n", ret);
 239                         return FALSE;
 240                 }
 241         } else if (mode == TEST_ENCODE_BUFFER) {
 242                 ret = mm_util_encode_jxl_to_buffer(g_decoded_data, g_enc_opt, &encoded_data, &encoded_size);
 243                 if (ret != MM_UTIL_ERROR_NONE) {
 244                         g_print("\t[JXL_testsuite] mm_util_encode_jxl_to_buffer failed : %d\n", ret);
 245                         MMUTIL_SAFE_FREE(encoded_data);
 246                         return FALSE;
 247                 }
 248                 ret = mm_util_file_write(g_test_filename[mode][color], encoded_data, encoded_size);
 249                 if (ret != MM_UTIL_ERROR_NONE)
 250                         g_print("\t[JXL_testsuite] mm_util_file_write failed : %d\n", ret);
 251
 252                 MMUTIL_SAFE_FREE(encoded_data);
 253         }
 254
 255         return TRUE;
 256 }
 257
 258 static void __test_auto(void)
 259 {
 260         mm_util_color_format_e color = 0;
 261         gboolean result = FALSE;
 262
 263         /* test for both decoding & encoding */
 264         for (color = 0; color < MM_UTIL_COLOR_NUM; color++) {
 265                 if (g_test_filename[TEST_DECODE_FILE][color]) {    // check supported
 266                         result = __test_decode(TEST_DECODE_FILE, color);
 267                         g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n",
 268                                         MODE_TO_STR[TEST_DECODE_FILE], color, (result) ? "SUCCESS" : "FAIL");
 269                 }
 270
 271                 if (g_test_filename[TEST_ENCODE_FILE][color]) {    // check supported
 272                         result = __test_encode(TEST_ENCODE_FILE, color);
 273                         g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n",
 274                                         MODE_TO_STR[TEST_ENCODE_FILE], color, (result) ? "SUCCESS" : "FAIL");
 275                 }
 276
 277                 if (g_test_filename[TEST_DECODE_BUFFER][color]) {    // check supported
 278                         result = __test_decode(TEST_DECODE_BUFFER, color);
 279                         g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n",
 280                                                         MODE_TO_STR[TEST_DECODE_BUFFER], color, (result) ? "SUCCESS" : "FAIL");
 281                 }
 282
 283                 if (g_test_filename[TEST_ENCODE_BUFFER][color]) {    // check supported
 284                         result = __test_encode(TEST_ENCODE_BUFFER, color);
 285                         g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n",
 286                                         MODE_TO_STR[TEST_ENCODE_BUFFER], color, (result) ? "SUCCESS" : "FAIL");
 287                 }
 288         }
 289 }
 290
 291 int main(int argc, char *argv[])
 292 {
 293         if (argc < 2) {
 294                 __print_help(argv[0]);
 295                 return 0;
 296         }
 297
 298         if (!__get_arguments(argc, argv)) {
 299                 g_print("\t[JXL_testsuite] _get_arguments failed\n");
 300                 goto out;
 301         }
 302
 303         /* test all functions automatically */
 304         switch (g_test_mode) {
 305         case TEST_AUTO:
 306                 __set_enc_opt(g_lossless);
 307                 __test_auto();
 308                 break;
 309         case TEST_DECODE_FILE:
 310         case TEST_DECODE_BUFFER:
 311                 g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n", MODE_TO_STR[g_test_mode],
 312                                         g_color, (__test_decode(g_test_mode, g_color)) ? "SUCCESS" : "FAIL");
 313                 break;
 314         case TEST_ENCODE_FILE:
 315         case TEST_ENCODE_BUFFER:
 316                 if (!__get_decoded_data()) {
 317                         g_print("\t[JXL_testsuite] __get_decoded_data failed\n");
 318                         goto out;
 319                 }
 320                 __set_enc_opt(g_lossless);
 321                 g_print("\t[JXL_testsuite] >>>>>>>>>>>>>>>>>>>>>> \'%s(%d)\' TEST %s\n", MODE_TO_STR[g_test_mode],
 322                                         g_color, (__test_encode(g_test_mode, g_color)) ? "SUCCESS" : "FAIL");
 323                 break;
 324         default:
 325                 __print_help(argv[0]);
 326                 break;
 327         }
 328
 329 out:
 330         MMUTIL_SAFE_FREE(g_path);
 331         MMUTIL_SAFE_FREE(g_read_data);
 332         MMUTIL_SAFE_IMAGE_FREE(g_decoded_data);
 333         mm_util_enc_opt_destroy(g_enc_opt);
 334
 335         return 0;
 336 }