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_half.h"
  34 #include "util/u_format.h"
  35 #include "util/u_format_tests.h"
  36 #include "util/u_format_s3tc.h"
  37
  38
  39 static boolean
  40 compare_float(float x, float y)
  41 {
  42    float error = y - x;
  43
  44    if (error < 0.0f)
  45       error = -error;
  46
  47    if (error > FLT_EPSILON) {
  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] = { { { 0 } } };
 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] = { { { 0 } } };
 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    if (test->format == PIPE_FORMAT_DXT1_RGBA) {
 205       /*
 206        * Skip S3TC as packed representation is not canonical.
 207        *
 208        * TODO: Do a round trip conversion.
 209        */
 210       return TRUE;
 211    }
 212
 213    memset(packed, 0, sizeof packed);
 214    for (i = 0; i < format_desc->block.height; ++i) {
 215       for (j = 0; j < format_desc->block.width; ++j) {
 216          for (k = 0; k < 4; ++k) {
 217             unpacked[i][j][k] = (float) test->unpacked[i][j][k];
 218          }
 219       }
 220    }
 221
 222    format_desc->pack_float(packed, 0, &unpacked[0][0][0], sizeof unpacked[0], format_desc->block.width, format_desc->block.height);
 223
 224    success = TRUE;
 225    for (i = 0; i < format_desc->block.bits/8; ++i)
 226       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
 227          success = FALSE;
 228
 229    if (!success) {
 230       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
 231       print_packed(format_desc, "        ", test->packed, " expected\n");
 232    }
 233
 234    return success;
 235 }
 236
 237
 238 static boolean
 239 convert_float_to_8unorm(uint8_t *dst, const double *src)
 240 {
 241    unsigned i;
 242    boolean accurate = TRUE;
 243
 244    for (i = 0; i < UTIL_FORMAT_MAX_UNPACKED_HEIGHT*UTIL_FORMAT_MAX_UNPACKED_WIDTH*4; ++i) {
 245       if (src[i] < 0.0) {
 246          accurate = FALSE;
 247          dst[i] = 0;
 248       }
 249       else if (src[i] > 1.0) {
 250          accurate = FALSE;
 251          dst[i] = 255;
 252       }
 253       else {
 254          dst[i] = src[i] * 255.0;
 255       }
 256    }
 257
 258    return accurate;
 259 }
 260
 261
 262 static boolean
 263 test_format_unpack_8unorm(const struct util_format_description *format_desc,
 264                           const struct util_format_test_case *test)
 265 {
 266    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
 267    uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
 268    unsigned i, j, k;
 269    boolean success;
 270
 271    format_desc->unpack_8unorm(&unpacked[0][0][0], sizeof unpacked[0], test->packed, 0, 1, 1);
 272
 273    convert_float_to_8unorm(&expected[0][0][0], &test->unpacked[0][0][0]);
 274
 275    success = TRUE;
 276    for (i = 0; i < format_desc->block.height; ++i) {
 277       for (j = 0; j < format_desc->block.width; ++j) {
 278          for (k = 0; k < 4; ++k) {
 279             if (expected[i][j][k] != unpacked[i][j][k]) {
 280                success = FALSE;
 281             }
 282          }
 283       }
 284    }
 285
 286    if (!success) {
 287       print_unpacked_8unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
 288       print_unpacked_8unorm(format_desc, "        ", expected, " expected\n");
 289    }
 290
 291    return success;
 292 }
 293
 294
 295 static boolean
 296 test_format_pack_8unorm(const struct util_format_description *format_desc,
 297                         const struct util_format_test_case *test)
 298 {
 299    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
 300    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
 301    unsigned i;
 302    boolean success;
 303
 304    if (test->format == PIPE_FORMAT_DXT1_RGBA) {
 305       /*
 306        * Skip S3TC as packed representation is not canonical.
 307        *
 308        * TODO: Do a round trip conversion.
 309        */
 310       return TRUE;
 311    }
 312
 313    if (!convert_float_to_8unorm(&unpacked[0][0][0], &test->unpacked[0][0][0])) {
 314       /*
 315        * Skip test cases which cannot be represented by four unorm bytes.
 316        */
 317       return TRUE;
 318    }
 319
 320    memset(packed, 0, sizeof packed);
 321
 322    format_desc->pack_8unorm(packed, 0, &unpacked[0][0][0], sizeof unpacked[0], 1, 1);
 323
 324    success = TRUE;
 325    for (i = 0; i < format_desc->block.bits/8; ++i)
 326       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
 327          success = FALSE;
 328
 329    if (!success) {
 330       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
 331       print_packed(format_desc, "        ", test->packed, " expected\n");
 332    }
 333
 334    return success;
 335 }
 336
 337
 338 typedef boolean
 339 (*test_func_t)(const struct util_format_description *format_desc,
 340                const struct util_format_test_case *test);
 341
 342
 343 static boolean
 344 test_one(test_func_t func, const char *suffix)
 345 {
 346    enum pipe_format last_format = PIPE_FORMAT_NONE;
 347    unsigned i;
 348    bool success = TRUE;
 349
 350    for (i = 0; i < util_format_nr_test_cases; ++i) {
 351       const struct util_format_test_case *test = &util_format_test_cases[i];
 352       const struct util_format_description *format_desc;
 353       bool skip = FALSE;
 354
 355       format_desc = util_format_description(test->format);
 356
 357       if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC &&
 358           !util_format_s3tc_enabled) {
 359          skip = TRUE;
 360       }
 361
 362       if (test->format != last_format) {
 363          printf("%s util_format_%s_%s ...\n",
 364                 skip ? "Skipping" : "Testing", format_desc->short_name, suffix);
 365          last_format = test->format;
 366       }
 367
 368       if (!skip) {
 369          if (!func(format_desc, &util_format_test_cases[i])) {
 370            success = FALSE;
 371          }
 372       }
 373    }
 374
 375    return success;
 376 }
 377
 378
 379 static boolean
 380 test_all(void)
 381 {
 382    bool success = TRUE;
 383
 384    if (!test_one(&test_format_fetch_float, "fetch_float"))
 385      success = FALSE;
 386
 387    if (!test_one(&test_format_pack_float, "pack_float"))
 388      success = FALSE;
 389
 390    if (!test_one(&test_format_unpack_float, "unpack_float"))
 391      success = FALSE;
 392
 393    if (!test_one(&test_format_pack_8unorm, "pack_8unorm"))
 394      success = FALSE;
 395
 396    if (!test_one(&test_format_unpack_8unorm, "unpack_8unorm"))
 397      success = FALSE;
 398
 399    return success;
 400 }
 401
 402
 403 int main(int argc, char **argv)
 404 {
 405    boolean success;
 406
 407    util_format_s3tc_init();
 408
 409    success = test_all();
 410
 411    return success ? 0 : 1;
 412 }