progs/gallium/unit/u_format_test.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009-2010 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <float.h>
  32
  33 #include "util/u_format.h"
  34 #include "util/u_format_tests.h"
  35 #include "util/u_format_s3tc.h"
  36
  37
  38 static boolean
  39 compare_float(float x, float y)
  40 {
  41    float error = y - x;
  42
  43    if (error < 0.0f)
  44       error = -error;
  45
  46    if (error > FLT_EPSILON) {
  47       printf("error = %g\n", error);
  48       return FALSE;
  49    }
  50
  51    return TRUE;
  52 }
  53
  54
  55 static void
  56 print_packed(const struct util_format_description *format_desc,
  57              const char *prefix,
  58              const uint8_t *packed,
  59              const char *suffix)
  60 {
  61    unsigned i;
  62    const char *sep = "";
  63
  64    printf("%s", prefix);
  65    for (i = 0; i < format_desc->block.bits/8; ++i) {
  66       printf("%s%02x", sep, packed[i]);
  67       sep = " ";
  68    }
  69    printf("%s", suffix);
  70 }
  71
  72
  73 static void
  74 print_unpacked_doubl(const struct util_format_description *format_desc,
  75                      const char *prefix,
  76                      const double unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
  77                      const char *suffix)
  78 {
  79    unsigned i, j;
  80    const char *sep = "";
  81
  82    printf("%s", prefix);
  83    for (i = 0; i < format_desc->block.height; ++i) {
  84       for (j = 0; j < format_desc->block.width; ++j) {
  85          printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
  86          sep = ", ";
  87       }
  88       sep = ",\n";
  89    }
  90    printf("%s", suffix);
  91 }
  92
  93
  94 static void
  95 print_unpacked_float(const struct util_format_description *format_desc,
  96                      const char *prefix,
  97                      const float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
  98                      const char *suffix)
  99 {
 100    unsigned i, j;
 101    const char *sep = "";
 102
 103    printf("%s", prefix);
 104    for (i = 0; i < format_desc->block.height; ++i) {
 105       for (j = 0; j < format_desc->block.width; ++j) {
 106          printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
 107          sep = ", ";
 108       }
 109       sep = ",\n";
 110    }
 111    printf("%s", suffix);
 112 }
 113
 114
 115 static void
 116 print_unpacked_8unorm(const struct util_format_description *format_desc,
 117                       const char *prefix,
 118                       const uint8_t unpacked[][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
 119                       const char *suffix)
 120 {
 121    unsigned i, j;
 122    const char *sep = "";
 123
 124    printf("%s", prefix);
 125    for (i = 0; i < format_desc->block.height; ++i) {
 126       for (j = 0; j < format_desc->block.width; ++j) {
 127          printf("%s{0x%02x, 0x%02x, 0x%02x, 0x%02x}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
 128          sep = ", ";
 129       }
 130    }
 131    printf("%s", suffix);
 132 }
 133
 134
 135 static boolean
 136 test_format_fetch_float(const struct util_format_description *format_desc,
 137                         const struct util_format_test_case *test)
 138 {
 139    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 140    unsigned i, j, k;
 141    boolean success;
 142
 143    success = TRUE;
 144    for (i = 0; i < format_desc->block.height; ++i) {
 145       for (j = 0; j < format_desc->block.width; ++j) {
 146          format_desc->fetch_float(unpacked[i][j], test->packed, j, i);
 147          for (k = 0; k < 4; ++k) {
 148             if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
 149                success = FALSE;
 150             }
 151          }
 152       }
 153    }
 154
 155    if (!success) {
 156       print_unpacked_float(format_desc, "FAILED: ", unpacked, " obtained\n");
 157       print_unpacked_doubl(format_desc, "        ", test->unpacked, " expected\n");
 158    }
 159
 160    return success;
 161 }
 162
 163
 164 static boolean
 165 test_format_unpack_float(const struct util_format_description *format_desc,
 166                          const struct util_format_test_case *test)
 167 {
 168    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 169    unsigned i, j, k;
 170    boolean success;
 171
 172    format_desc->unpack_float(&unpacked[0][0][0], sizeof unpacked[0], test->packed, 0, format_desc->block.width, format_desc->block.height);
 173
 174    success = TRUE;
 175    for (i = 0; i < format_desc->block.height; ++i) {
 176       for (j = 0; j < format_desc->block.width; ++j) {
 177          for (k = 0; k < 4; ++k) {
 178             if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
 179                success = FALSE;
 180             }
 181          }
 182       }
 183    }
 184
 185    if (!success) {
 186       print_unpacked_float(format_desc, "FAILED: ", unpacked, " obtained\n");
 187       print_unpacked_doubl(format_desc, "        ", test->unpacked, " expected\n");
 188    }
 189
 190    return success;
 191 }
 192
 193
 194 static boolean
 195
 196 test_format_pack_float(const struct util_format_description *format_desc,
 197                        const struct util_format_test_case *test)
 198 {
 199    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 200    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
 201    unsigned i, j, k;
 202    boolean success;
 203
 204    memset(packed, 0, sizeof packed);
 205    for (i = 0; i < format_desc->block.height; ++i) {
 206       for (j = 0; j < format_desc->block.width; ++j) {
 207          for (k = 0; k < 4; ++k) {
 208             unpacked[i][j][k] = (float) test->unpacked[i][j][k];
 209          }
 210       }
 211    }
 212
 213    format_desc->pack_float(packed, 0, &unpacked[0][0][0], sizeof unpacked[0], format_desc->block.width, format_desc->block.height);
 214
 215    success = TRUE;
 216    for (i = 0; i < format_desc->block.bits/8; ++i)
 217       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
 218          success = FALSE;
 219
 220    if (!success) {
 221       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
 222       print_packed(format_desc, "        ", test->packed, " expected\n");
 223    }
 224
 225    return success;
 226 }
 227
 228
 229 static boolean
 230 convert_float_to_8unorm(uint8_t *dst, const double *src)
 231 {
 232    unsigned i;
 233    boolean accurate = TRUE;
 234
 235    for (i = 0; i < UTIL_FORMAT_MAX_UNPACKED_HEIGHT*UTIL_FORMAT_MAX_UNPACKED_WIDTH*4; ++i) {
 236       if (src[i] < 0.0) {
 237          accurate = FALSE;
 238          dst[i] = 0;
 239       }
 240       else if (src[i] > 1.0) {
 241          accurate = FALSE;
 242          dst[i] = 255;
 243       }
 244       else {
 245          dst[i] = src[i] * 255.0;
 246       }
 247    }
 248
 249    return accurate;
 250 }
 251
 252
 253 static boolean
 254 test_format_unpack_8unorm(const struct util_format_description *format_desc,
 255                           const struct util_format_test_case *test)
 256 {
 257    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 258    uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 259    unsigned i, j, k;
 260    boolean success;
 261
 262    format_desc->unpack_8unorm(&unpacked[0][0][0], 0, test->packed, 0, 1, 1);
 263
 264    convert_float_to_8unorm(&expected[0][0][0], &test->unpacked[0][0][0]);
 265
 266    success = TRUE;
 267    for (i = 0; i < format_desc->block.height; ++i) {
 268       for (j = 0; j < format_desc->block.width; ++j) {
 269          for (k = 0; k < 4; ++k) {
 270             if (expected[i][j][k] != unpacked[i][j][k]) {
 271                success = FALSE;
 272             }
 273          }
 274       }
 275    }
 276
 277    if (!success) {
 278       print_unpacked_8unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
 279       print_unpacked_8unorm(format_desc, "        ", expected, " expected\n");
 280    }
 281
 282    return success;
 283 }
 284
 285
 286 static boolean
 287 test_format_pack_8unorm(const struct util_format_description *format_desc,
 288                         const struct util_format_test_case *test)
 289 {
 290    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 291    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
 292    unsigned i;
 293    boolean success;
 294
 295    if (!convert_float_to_8unorm(&unpacked[0][0][0], &test->unpacked[0][0][0])) {
 296       /*
 297        * Skip test cases which cannot be represented by four unorm bytes.
 298        */
 299       return TRUE;
 300    }
 301
 302    memset(packed, 0, sizeof packed);
 303
 304    format_desc->pack_8unorm(packed, 0, &unpacked[0][0][0], sizeof unpacked[0], 1, 1);
 305
 306    success = TRUE;
 307    for (i = 0; i < format_desc->block.bits/8; ++i)
 308       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
 309          success = FALSE;
 310
 311    if (!success) {
 312       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
 313       print_packed(format_desc, "        ", test->packed, " expected\n");
 314    }
 315
 316    return success;
 317 }
 318
 319
 320 typedef boolean
 321 (*test_func_t)(const struct util_format_description *format_desc,
 322                const struct util_format_test_case *test);
 323
 324
 325 static boolean
 326 test_one(test_func_t func, const char *suffix)
 327 {
 328    enum pipe_format last_format = PIPE_FORMAT_NONE;
 329    unsigned i;
 330    bool success = TRUE;
 331
 332    for (i = 0; i < util_format_nr_test_cases; ++i) {
 333       const struct util_format_test_case *test = &util_format_test_cases[i];
 334       const struct util_format_description *format_desc;
 335       bool skip = FALSE;
 336
 337       format_desc = util_format_description(test->format);
 338
 339       if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC &&
 340           !util_format_s3tc_enabled) {
 341          skip = TRUE;
 342       }
 343
 344       if (test->format != last_format) {
 345          printf("%s util_format_%s_%s ...\n",
 346                 skip ? "Skipping" : "Testing", format_desc->short_name, suffix);
 347          last_format = test->format;
 348       }
 349
 350       if (!skip) {
 351          if (!func(format_desc, &util_format_test_cases[i])) {
 352            success = FALSE;
 353          }
 354       }
 355    }
 356
 357    return success;
 358 }
 359
 360
 361 static boolean
 362 test_all(void)
 363 {
 364    bool success = TRUE;
 365
 366    if (!test_one(&test_format_fetch_float, "fetch_float"))
 367      success = FALSE;
 368
 369    if (!test_one(&test_format_pack_float, "pack_float"))
 370      success = FALSE;
 371
 372    if (!test_one(&test_format_unpack_float, "unpack_float"))
 373      success = FALSE;
 374
 375    if (!test_one(&test_format_pack_8unorm, "pack_8unorm"))
 376      success = FALSE;
 377
 378    if (!test_one(&test_format_unpack_8unorm, "unpack_8unorm"))
 379      success = FALSE;
 380
 381    return success;
 382 }
 383
 384
 385 int main(int argc, char **argv)
 386 {
 387    boolean success;
 388
 389    util_format_s3tc_init();
 390
 391    success = test_all();
 392
 393    return success ? 0 : 1;
 394 }