Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.    fflush(stdout);
  71. }
  72.  
  73.  
  74. static void
  75. print_unpacked_rgba_doubl(const struct util_format_description *format_desc,
  76.                      const char *prefix,
  77.                      const double unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
  78.                      const char *suffix)
  79. {
  80.    unsigned i, j;
  81.    const char *sep = "";
  82.  
  83.    printf("%s", prefix);
  84.    for (i = 0; i < format_desc->block.height; ++i) {
  85.       for (j = 0; j < format_desc->block.width; ++j) {
  86.          printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
  87.          sep = ", ";
  88.       }
  89.       sep = ",\n";
  90.    }
  91.    printf("%s", suffix);
  92.    fflush(stdout);
  93. }
  94.  
  95.  
  96. static void
  97. print_unpacked_rgba_float(const struct util_format_description *format_desc,
  98.                      const char *prefix,
  99.                      float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
  100.                      const char *suffix)
  101. {
  102.    unsigned i, j;
  103.    const char *sep = "";
  104.  
  105.    printf("%s", prefix);
  106.    for (i = 0; i < format_desc->block.height; ++i) {
  107.       for (j = 0; j < format_desc->block.width; ++j) {
  108.          printf("%s{%f, %f, %f, %f}", sep, unpacked[i][j][0], unpacked[i][j][1], unpacked[i][j][2], unpacked[i][j][3]);
  109.          sep = ", ";
  110.       }
  111.       sep = ",\n";
  112.    }
  113.    printf("%s", suffix);
  114.    fflush(stdout);
  115. }
  116.  
  117.  
  118. static void
  119. print_unpacked_rgba_8unorm(const struct util_format_description *format_desc,
  120.                       const char *prefix,
  121.                       uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4],
  122.                       const char *suffix)
  123. {
  124.    unsigned i, j;
  125.    const char *sep = "";
  126.  
  127.    printf("%s", prefix);
  128.    for (i = 0; i < format_desc->block.height; ++i) {
  129.       for (j = 0; j < format_desc->block.width; ++j) {
  130.          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]);
  131.          sep = ", ";
  132.       }
  133.    }
  134.    printf("%s", suffix);
  135.    fflush(stdout);
  136. }
  137.  
  138.  
  139. static void
  140. print_unpacked_z_float(const struct util_format_description *format_desc,
  141.                        const char *prefix,
  142.                        float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
  143.                        const char *suffix)
  144. {
  145.    unsigned i, j;
  146.    const char *sep = "";
  147.  
  148.    printf("%s", prefix);
  149.    for (i = 0; i < format_desc->block.height; ++i) {
  150.       for (j = 0; j < format_desc->block.width; ++j) {
  151.          printf("%s%f", sep, unpacked[i][j]);
  152.          sep = ", ";
  153.       }
  154.       sep = ",\n";
  155.    }
  156.    printf("%s", suffix);
  157.    fflush(stdout);
  158. }
  159.  
  160.  
  161. static void
  162. print_unpacked_z_32unorm(const struct util_format_description *format_desc,
  163.                          const char *prefix,
  164.                          uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
  165.                          const char *suffix)
  166. {
  167.    unsigned i, j;
  168.    const char *sep = "";
  169.  
  170.    printf("%s", prefix);
  171.    for (i = 0; i < format_desc->block.height; ++i) {
  172.       for (j = 0; j < format_desc->block.width; ++j) {
  173.          printf("%s0x%08x", sep, unpacked[i][j]);
  174.          sep = ", ";
  175.       }
  176.    }
  177.    printf("%s", suffix);
  178.    fflush(stdout);
  179. }
  180.  
  181.  
  182. static void
  183. print_unpacked_s_8uint(const struct util_format_description *format_desc,
  184.                        const char *prefix,
  185.                        uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH],
  186.                        const char *suffix)
  187. {
  188.    unsigned i, j;
  189.    const char *sep = "";
  190.  
  191.    printf("%s", prefix);
  192.    for (i = 0; i < format_desc->block.height; ++i) {
  193.       for (j = 0; j < format_desc->block.width; ++j) {
  194.          printf("%s0x%02x", sep, unpacked[i][j]);
  195.          sep = ", ";
  196.       }
  197.    }
  198.    printf("%s", suffix);
  199.    fflush(stdout);
  200. }
  201.  
  202.  
  203. static boolean
  204. test_format_fetch_rgba_float(const struct util_format_description *format_desc,
  205.                              const struct util_format_test_case *test)
  206. {
  207.    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
  208.    unsigned i, j, k;
  209.    boolean success;
  210.  
  211.    success = TRUE;
  212.    for (i = 0; i < format_desc->block.height; ++i) {
  213.       for (j = 0; j < format_desc->block.width; ++j) {
  214.          format_desc->fetch_rgba_float(unpacked[i][j], test->packed, j, i);
  215.          for (k = 0; k < 4; ++k) {
  216.             if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
  217.                success = FALSE;
  218.             }
  219.          }
  220.       }
  221.    }
  222.  
  223.    if (!success) {
  224.       print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
  225.       print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
  226.    }
  227.  
  228.    return success;
  229. }
  230.  
  231.  
  232. static boolean
  233. test_format_unpack_rgba_float(const struct util_format_description *format_desc,
  234.                               const struct util_format_test_case *test)
  235. {
  236.    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
  237.    unsigned i, j, k;
  238.    boolean success;
  239.  
  240.    format_desc->unpack_rgba_float(&unpacked[0][0][0], sizeof unpacked[0],
  241.                              test->packed, 0,
  242.                              format_desc->block.width, format_desc->block.height);
  243.  
  244.    success = TRUE;
  245.    for (i = 0; i < format_desc->block.height; ++i) {
  246.       for (j = 0; j < format_desc->block.width; ++j) {
  247.          for (k = 0; k < 4; ++k) {
  248.             if (!compare_float(test->unpacked[i][j][k], unpacked[i][j][k])) {
  249.                success = FALSE;
  250.             }
  251.          }
  252.       }
  253.    }
  254.  
  255.    if (!success) {
  256.       print_unpacked_rgba_float(format_desc, "FAILED: ", unpacked, " obtained\n");
  257.       print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
  258.    }
  259.  
  260.    return success;
  261. }
  262.  
  263.  
  264. static boolean
  265. test_format_pack_rgba_float(const struct util_format_description *format_desc,
  266.                             const struct util_format_test_case *test)
  267. {
  268.    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
  269.    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
  270.    unsigned i, j, k;
  271.    boolean success;
  272.  
  273.    if (test->format == PIPE_FORMAT_DXT1_RGBA) {
  274.       /*
  275.        * Skip S3TC as packed representation is not canonical.
  276.        *
  277.        * TODO: Do a round trip conversion.
  278.        */
  279.       return TRUE;
  280.    }
  281.  
  282.    memset(packed, 0, sizeof packed);
  283.    for (i = 0; i < format_desc->block.height; ++i) {
  284.       for (j = 0; j < format_desc->block.width; ++j) {
  285.          for (k = 0; k < 4; ++k) {
  286.             unpacked[i][j][k] = (float) test->unpacked[i][j][k];
  287.          }
  288.       }
  289.    }
  290.  
  291.    format_desc->pack_rgba_float(packed, 0,
  292.                            &unpacked[0][0][0], sizeof unpacked[0],
  293.                            format_desc->block.width, format_desc->block.height);
  294.  
  295.    success = TRUE;
  296.    for (i = 0; i < format_desc->block.bits/8; ++i) {
  297.       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
  298.          success = FALSE;
  299.    }
  300.  
  301.    /* Ignore NaN */
  302.    if (util_is_double_nan(test->unpacked[0][0][0]))
  303.       success = TRUE;
  304.  
  305.    if (!success) {
  306.       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
  307.       print_packed(format_desc, "        ", test->packed, " expected\n");
  308.    }
  309.  
  310.    return success;
  311. }
  312.  
  313.  
  314. static boolean
  315. convert_float_to_8unorm(uint8_t *dst, const double *src)
  316. {
  317.    unsigned i;
  318.    boolean accurate = TRUE;
  319.  
  320.    for (i = 0; i < UTIL_FORMAT_MAX_UNPACKED_HEIGHT*UTIL_FORMAT_MAX_UNPACKED_WIDTH*4; ++i) {
  321.       if (src[i] < 0.0) {
  322.          accurate = FALSE;
  323.          dst[i] = 0;
  324.       }
  325.       else if (src[i] > 1.0) {
  326.          accurate = FALSE;
  327.          dst[i] = 255;
  328.       }
  329.       else {
  330.          dst[i] = src[i] * 255.0;
  331.       }
  332.    }
  333.  
  334.    return accurate;
  335. }
  336.  
  337.  
  338. static boolean
  339. test_format_unpack_rgba_8unorm(const struct util_format_description *format_desc,
  340.                                const struct util_format_test_case *test)
  341. {
  342.    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
  343.    uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4] = { { { 0 } } };
  344.    unsigned i, j, k;
  345.    boolean success;
  346.  
  347.    format_desc->unpack_rgba_8unorm(&unpacked[0][0][0], sizeof unpacked[0],
  348.                               test->packed, 0,
  349.                               format_desc->block.width, format_desc->block.height);
  350.  
  351.    convert_float_to_8unorm(&expected[0][0][0], &test->unpacked[0][0][0]);
  352.  
  353.    success = TRUE;
  354.    for (i = 0; i < format_desc->block.height; ++i) {
  355.       for (j = 0; j < format_desc->block.width; ++j) {
  356.          for (k = 0; k < 4; ++k) {
  357.             if (expected[i][j][k] != unpacked[i][j][k]) {
  358.                success = FALSE;
  359.             }
  360.          }
  361.       }
  362.    }
  363.  
  364.    /* Ignore NaN */
  365.    if (util_is_double_nan(test->unpacked[0][0][0]))
  366.       success = TRUE;
  367.  
  368.    if (!success) {
  369.       print_unpacked_rgba_8unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
  370.       print_unpacked_rgba_8unorm(format_desc, "        ", expected, " expected\n");
  371.    }
  372.  
  373.    return success;
  374. }
  375.  
  376.  
  377. static boolean
  378. test_format_pack_rgba_8unorm(const struct util_format_description *format_desc,
  379.                              const struct util_format_test_case *test)
  380. {
  381.    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH][4];
  382.    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
  383.    unsigned i;
  384.    boolean success;
  385.  
  386.    if (test->format == PIPE_FORMAT_DXT1_RGBA) {
  387.       /*
  388.        * Skip S3TC as packed representation is not canonical.
  389.        *
  390.        * TODO: Do a round trip conversion.
  391.        */
  392.       return TRUE;
  393.    }
  394.  
  395.    if (!convert_float_to_8unorm(&unpacked[0][0][0], &test->unpacked[0][0][0])) {
  396.       /*
  397.        * Skip test cases which cannot be represented by four unorm bytes.
  398.        */
  399.       return TRUE;
  400.    }
  401.  
  402.    memset(packed, 0, sizeof packed);
  403.  
  404.    format_desc->pack_rgba_8unorm(packed, 0,
  405.                             &unpacked[0][0][0], sizeof unpacked[0],
  406.                             format_desc->block.width, format_desc->block.height);
  407.  
  408.    success = TRUE;
  409.    for (i = 0; i < format_desc->block.bits/8; ++i)
  410.       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
  411.          success = FALSE;
  412.  
  413.    /* Ignore NaN */
  414.    if (util_is_double_nan(test->unpacked[0][0][0]))
  415.       success = TRUE;
  416.  
  417.    /* Ignore failure cases due to unorm8 format */
  418.    if (test->unpacked[0][0][0] > 1.0f || test->unpacked[0][0][0] < 0.0f)
  419.       success = TRUE;
  420.  
  421.    /* Multiple of 255 */
  422.    if ((test->unpacked[0][0][0] * 255.0) != (int)(test->unpacked[0][0][0] * 255.0))
  423.       success = TRUE;
  424.  
  425.    if (!success) {
  426.       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
  427.       print_packed(format_desc, "        ", test->packed, " expected\n");
  428.    }
  429.  
  430.    return success;
  431. }
  432.  
  433.  
  434. static boolean
  435. test_format_unpack_z_float(const struct util_format_description *format_desc,
  436.                               const struct util_format_test_case *test)
  437. {
  438.    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
  439.    unsigned i, j;
  440.    boolean success;
  441.  
  442.    format_desc->unpack_z_float(&unpacked[0][0], sizeof unpacked[0],
  443.                                test->packed, 0,
  444.                                format_desc->block.width, format_desc->block.height);
  445.  
  446.    success = TRUE;
  447.    for (i = 0; i < format_desc->block.height; ++i) {
  448.       for (j = 0; j < format_desc->block.width; ++j) {
  449.          if (!compare_float(test->unpacked[i][j][0], unpacked[i][j])) {
  450.             success = FALSE;
  451.          }
  452.       }
  453.    }
  454.  
  455.    if (!success) {
  456.       print_unpacked_z_float(format_desc, "FAILED: ", unpacked, " obtained\n");
  457.       print_unpacked_rgba_doubl(format_desc, "        ", test->unpacked, " expected\n");
  458.    }
  459.  
  460.    return success;
  461. }
  462.  
  463.  
  464. static boolean
  465. test_format_pack_z_float(const struct util_format_description *format_desc,
  466.                             const struct util_format_test_case *test)
  467. {
  468.    float unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
  469.    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
  470.    unsigned i, j;
  471.    boolean success;
  472.  
  473.    memset(packed, 0, sizeof packed);
  474.    for (i = 0; i < format_desc->block.height; ++i) {
  475.       for (j = 0; j < format_desc->block.width; ++j) {
  476.          unpacked[i][j] = (float) test->unpacked[i][j][0];
  477.          if (test->unpacked[i][j][1]) {
  478.             return TRUE;
  479.          }
  480.       }
  481.    }
  482.  
  483.    format_desc->pack_z_float(packed, 0,
  484.                              &unpacked[0][0], sizeof unpacked[0],
  485.                              format_desc->block.width, format_desc->block.height);
  486.  
  487.    success = TRUE;
  488.    for (i = 0; i < format_desc->block.bits/8; ++i)
  489.       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
  490.          success = FALSE;
  491.  
  492.    if (!success) {
  493.       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
  494.       print_packed(format_desc, "        ", test->packed, " expected\n");
  495.    }
  496.  
  497.    return success;
  498. }
  499.  
  500.  
  501. static boolean
  502. test_format_unpack_z_32unorm(const struct util_format_description *format_desc,
  503.                                const struct util_format_test_case *test)
  504. {
  505.    uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
  506.    uint32_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
  507.    unsigned i, j;
  508.    boolean success;
  509.  
  510.    format_desc->unpack_z_32unorm(&unpacked[0][0], sizeof unpacked[0],
  511.                                  test->packed, 0,
  512.                                  format_desc->block.width, format_desc->block.height);
  513.  
  514.    for (i = 0; i < format_desc->block.height; ++i) {
  515.       for (j = 0; j < format_desc->block.width; ++j) {
  516.          expected[i][j] = test->unpacked[i][j][0] * 0xffffffff;
  517.       }
  518.    }
  519.  
  520.    success = TRUE;
  521.    for (i = 0; i < format_desc->block.height; ++i) {
  522.       for (j = 0; j < format_desc->block.width; ++j) {
  523.          if (expected[i][j] != unpacked[i][j]) {
  524.             success = FALSE;
  525.          }
  526.       }
  527.    }
  528.  
  529.    if (!success) {
  530.       print_unpacked_z_32unorm(format_desc, "FAILED: ", unpacked, " obtained\n");
  531.       print_unpacked_z_32unorm(format_desc, "        ", expected, " expected\n");
  532.    }
  533.  
  534.    return success;
  535. }
  536.  
  537.  
  538. static boolean
  539. test_format_pack_z_32unorm(const struct util_format_description *format_desc,
  540.                              const struct util_format_test_case *test)
  541. {
  542.    uint32_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
  543.    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
  544.    unsigned i, j;
  545.    boolean success;
  546.  
  547.    for (i = 0; i < format_desc->block.height; ++i) {
  548.       for (j = 0; j < format_desc->block.width; ++j) {
  549.          unpacked[i][j] = test->unpacked[i][j][0] * 0xffffffff;
  550.          if (test->unpacked[i][j][1]) {
  551.             return TRUE;
  552.          }
  553.       }
  554.    }
  555.  
  556.    memset(packed, 0, sizeof packed);
  557.  
  558.    format_desc->pack_z_32unorm(packed, 0,
  559.                                &unpacked[0][0], sizeof unpacked[0],
  560.                                format_desc->block.width, format_desc->block.height);
  561.  
  562.    success = TRUE;
  563.    for (i = 0; i < format_desc->block.bits/8; ++i)
  564.       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
  565.          success = FALSE;
  566.  
  567.    if (!success) {
  568.       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
  569.       print_packed(format_desc, "        ", test->packed, " expected\n");
  570.    }
  571.  
  572.    return success;
  573. }
  574.  
  575.  
  576. static boolean
  577. test_format_unpack_s_8uint(const struct util_format_description *format_desc,
  578.                                const struct util_format_test_case *test)
  579. {
  580.    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
  581.    uint8_t expected[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH] = { { 0 } };
  582.    unsigned i, j;
  583.    boolean success;
  584.  
  585.    format_desc->unpack_s_8uint(&unpacked[0][0], sizeof unpacked[0],
  586.                                   test->packed, 0,
  587.                                   format_desc->block.width, format_desc->block.height);
  588.  
  589.    for (i = 0; i < format_desc->block.height; ++i) {
  590.       for (j = 0; j < format_desc->block.width; ++j) {
  591.          expected[i][j] = test->unpacked[i][j][1];
  592.       }
  593.    }
  594.  
  595.    success = TRUE;
  596.    for (i = 0; i < format_desc->block.height; ++i) {
  597.       for (j = 0; j < format_desc->block.width; ++j) {
  598.          if (expected[i][j] != unpacked[i][j]) {
  599.             success = FALSE;
  600.          }
  601.       }
  602.    }
  603.  
  604.    if (!success) {
  605.       print_unpacked_s_8uint(format_desc, "FAILED: ", unpacked, " obtained\n");
  606.       print_unpacked_s_8uint(format_desc, "        ", expected, " expected\n");
  607.    }
  608.  
  609.    return success;
  610. }
  611.  
  612.  
  613. static boolean
  614. test_format_pack_s_8uint(const struct util_format_description *format_desc,
  615.                              const struct util_format_test_case *test)
  616. {
  617.    uint8_t unpacked[UTIL_FORMAT_MAX_UNPACKED_HEIGHT][UTIL_FORMAT_MAX_UNPACKED_WIDTH];
  618.    uint8_t packed[UTIL_FORMAT_MAX_PACKED_BYTES];
  619.    unsigned i, j;
  620.    boolean success;
  621.  
  622.    for (i = 0; i < format_desc->block.height; ++i) {
  623.       for (j = 0; j < format_desc->block.width; ++j) {
  624.          unpacked[i][j] = test->unpacked[i][j][1];
  625.          if (test->unpacked[i][j][0]) {
  626.             return TRUE;
  627.          }
  628.       }
  629.    }
  630.  
  631.    memset(packed, 0, sizeof packed);
  632.  
  633.    format_desc->pack_s_8uint(packed, 0,
  634.                                 &unpacked[0][0], sizeof unpacked[0],
  635.                                 format_desc->block.width, format_desc->block.height);
  636.  
  637.    success = TRUE;
  638.    for (i = 0; i < format_desc->block.bits/8; ++i)
  639.       if ((test->packed[i] & test->mask[i]) != (packed[i] & test->mask[i]))
  640.          success = FALSE;
  641.  
  642.    if (!success) {
  643.       print_packed(format_desc, "FAILED: ", packed, " obtained\n");
  644.       print_packed(format_desc, "        ", test->packed, " expected\n");
  645.    }
  646.  
  647.    return success;
  648. }
  649.  
  650.  
  651. typedef boolean
  652. (*test_func_t)(const struct util_format_description *format_desc,
  653.                const struct util_format_test_case *test);
  654.  
  655.  
  656. static boolean
  657. test_one_func(const struct util_format_description *format_desc,
  658.               test_func_t func,
  659.               const char *suffix)
  660. {
  661.    unsigned i;
  662.    boolean success = TRUE;
  663.  
  664.    printf("Testing util_format_%s_%s ...\n",
  665.           format_desc->short_name, suffix);
  666.    fflush(stdout);
  667.  
  668.    for (i = 0; i < util_format_nr_test_cases; ++i) {
  669.       const struct util_format_test_case *test = &util_format_test_cases[i];
  670.  
  671.       if (test->format == format_desc->format) {
  672.          if (!func(format_desc, &util_format_test_cases[i])) {
  673.            success = FALSE;
  674.          }
  675.       }
  676.    }
  677.  
  678.    return success;
  679. }
  680.  
  681.  
  682. static boolean
  683. test_all(void)
  684. {
  685.    enum pipe_format format;
  686.    boolean success = TRUE;
  687.  
  688.    for (format = 1; format < PIPE_FORMAT_COUNT; ++format) {
  689.       const struct util_format_description *format_desc;
  690.  
  691.       format_desc = util_format_description(format);
  692.       if (!format_desc) {
  693.          continue;
  694.       }
  695.  
  696.       if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC &&
  697.           !util_format_s3tc_enabled) {
  698.          continue;
  699.       }
  700.  
  701. #     define TEST_ONE_FUNC(name) \
  702.       if (format_desc->name) { \
  703.          if (!test_one_func(format_desc, &test_format_##name, #name)) { \
  704.            success = FALSE; \
  705.          } \
  706.       }
  707.  
  708.       TEST_ONE_FUNC(fetch_rgba_float);
  709.       TEST_ONE_FUNC(pack_rgba_float);
  710.       TEST_ONE_FUNC(unpack_rgba_float);
  711.       TEST_ONE_FUNC(pack_rgba_8unorm);
  712.       TEST_ONE_FUNC(unpack_rgba_8unorm);
  713.  
  714.       TEST_ONE_FUNC(unpack_z_32unorm);
  715.       TEST_ONE_FUNC(pack_z_32unorm);
  716.       TEST_ONE_FUNC(unpack_z_float);
  717.       TEST_ONE_FUNC(pack_z_float);
  718.       TEST_ONE_FUNC(unpack_s_8uint);
  719.       TEST_ONE_FUNC(pack_s_8uint);
  720.  
  721. #     undef TEST_ONE_FUNC
  722.    }
  723.  
  724.    return success;
  725. }
  726.  
  727.  
  728. int main(int argc, char **argv)
  729. {
  730.    boolean success;
  731.  
  732.    util_format_s3tc_init();
  733.  
  734.    success = test_all();
  735.  
  736.    return success ? 0 : 1;
  737. }
  738.