src/gallium/auxiliary/util/u_format_s3tc.c

   1 /**************************************************************************
   2  *
   3  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   4  * Copyright (c) 2008 VMware, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  20  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  **************************************************************************/
  24
  25 #include "u_dl.h"
  26 #include "u_math.h"
  27 #include "u_format.h"
  28 #include "u_format_s3tc.h"
  29
  30
  31 #if defined(_WIN32) || defined(WIN32)
  32 #define DXTN_LIBNAME "dxtn.dll"
  33 #elif defined(__APPLE__)
  34 #define DXTN_LIBNAME "libtxc_dxtn.dylib"
  35 #else
  36 #define DXTN_LIBNAME "libtxc_dxtn.so"
  37 #endif
  38
  39
  40 static void
  41 util_format_dxt1_rgb_fetch_stub(int src_stride,
  42                                 const uint8_t *src,
  43                                 int col, int row,
  44                                 uint8_t *dst)
  45 {
  46    assert(0);
  47 }
  48
  49
  50 static void
  51 util_format_dxt1_rgba_fetch_stub(int src_stride,
  52                                  const uint8_t *src,
  53                                  int col, int row,
  54                                  uint8_t *dst )
  55 {
  56    assert(0);
  57 }
  58
  59
  60 static void
  61 util_format_dxt3_rgba_fetch_stub(int src_stride,
  62                                  const uint8_t *src,
  63                                  int col, int row,
  64                                  uint8_t *dst )
  65 {
  66    assert(0);
  67 }
  68
  69
  70 static void
  71 util_format_dxt5_rgba_fetch_stub(int src_stride,
  72                                  const uint8_t *src,
  73                                  int col, int row,
  74                                  uint8_t *dst )
  75 {
  76    assert(0);
  77 }
  78
  79
  80 static void
  81 util_format_dxtn_pack_stub(int src_comps,
  82                            int width, int height,
  83                            const uint8_t *src,
  84                            enum util_format_dxtn dst_format,
  85                            uint8_t *dst,
  86                            int dst_stride)
  87 {
  88    assert(0);
  89 }
  90
  91
  92 boolean util_format_s3tc_enabled = FALSE;
  93
  94 util_format_dxtn_fetch_t util_format_dxt1_rgb_fetch = util_format_dxt1_rgb_fetch_stub;
  95 util_format_dxtn_fetch_t util_format_dxt1_rgba_fetch = util_format_dxt1_rgba_fetch_stub;
  96 util_format_dxtn_fetch_t util_format_dxt3_rgba_fetch = util_format_dxt3_rgba_fetch_stub;
  97 util_format_dxtn_fetch_t util_format_dxt5_rgba_fetch = util_format_dxt5_rgba_fetch_stub;
  98
  99 util_format_dxtn_pack_t util_format_dxtn_pack = util_format_dxtn_pack_stub;
 100
 101
 102 void
 103 util_format_s3tc_init(void)
 104 {
 105    static boolean first_time = TRUE;
 106    struct util_dl_library *library = NULL;
 107    util_dl_proc fetch_2d_texel_rgb_dxt1;
 108    util_dl_proc fetch_2d_texel_rgba_dxt1;
 109    util_dl_proc fetch_2d_texel_rgba_dxt3;
 110    util_dl_proc fetch_2d_texel_rgba_dxt5;
 111    util_dl_proc tx_compress_dxtn;
 112
 113    if (!first_time)
 114       return;
 115    first_time = FALSE;
 116
 117    if (util_format_s3tc_enabled)
 118       return;
 119
 120    library = util_dl_open(DXTN_LIBNAME);
 121    if (!library) {
 122       debug_printf("couldn't open " DXTN_LIBNAME ", software DXTn "
 123          "compression/decompression unavailable\n");
 124       return;
 125    }
 126
 127    fetch_2d_texel_rgb_dxt1 =
 128          util_dl_get_proc_address(library, "fetch_2d_texel_rgb_dxt1");
 129    fetch_2d_texel_rgba_dxt1 =
 130          util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt1");
 131    fetch_2d_texel_rgba_dxt3 =
 132          util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt3");
 133    fetch_2d_texel_rgba_dxt5 =
 134          util_dl_get_proc_address(library, "fetch_2d_texel_rgba_dxt5");
 135    tx_compress_dxtn =
 136          util_dl_get_proc_address(library, "tx_compress_dxtn");
 137
 138    if (!util_format_dxt1_rgb_fetch ||
 139        !util_format_dxt1_rgba_fetch ||
 140        !util_format_dxt3_rgba_fetch ||
 141        !util_format_dxt5_rgba_fetch ||
 142        !util_format_dxtn_pack) {
 143       debug_printf("couldn't reference all symbols in " DXTN_LIBNAME
 144                    ", software DXTn compression/decompression "
 145                    "unavailable\n");
 146       util_dl_close(library);
 147       return;
 148    }
 149
 150    util_format_dxt1_rgb_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgb_dxt1;
 151    util_format_dxt1_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt1;
 152    util_format_dxt3_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt3;
 153    util_format_dxt5_rgba_fetch = (util_format_dxtn_fetch_t)fetch_2d_texel_rgba_dxt5;
 154    util_format_dxtn_pack = (util_format_dxtn_pack_t)tx_compress_dxtn;
 155    util_format_s3tc_enabled = TRUE;
 156 }
 157
 158
 159 /*
 160  * Pixel fetch.
 161  */
 162
 163 void
 164 util_format_dxt1_rgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 165 {
 166    util_format_dxt1_rgb_fetch(0, src, i, j, dst);
 167 }
 168
 169 void
 170 util_format_dxt1_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 171 {
 172    util_format_dxt1_rgba_fetch(0, src, i, j, dst);
 173 }
 174
 175 void
 176 util_format_dxt3_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 177 {
 178    util_format_dxt3_rgba_fetch(0, src, i, j, dst);
 179 }
 180
 181 void
 182 util_format_dxt5_rgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 183 {
 184    util_format_dxt5_rgba_fetch(0, src, i, j, dst);
 185 }
 186
 187 void
 188 util_format_dxt1_rgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 189 {
 190    uint8_t tmp[4];
 191    util_format_dxt1_rgb_fetch(0, src, i, j, tmp);
 192    dst[0] = ubyte_to_float(tmp[0]);
 193    dst[1] = ubyte_to_float(tmp[1]);
 194    dst[2] = ubyte_to_float(tmp[2]);
 195    dst[3] = 1.0;
 196 }
 197
 198 void
 199 util_format_dxt1_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 200 {
 201    uint8_t tmp[4];
 202    util_format_dxt1_rgba_fetch(0, src, i, j, tmp);
 203    dst[0] = ubyte_to_float(tmp[0]);
 204    dst[1] = ubyte_to_float(tmp[1]);
 205    dst[2] = ubyte_to_float(tmp[2]);
 206    dst[3] = ubyte_to_float(tmp[3]);
 207 }
 208
 209 void
 210 util_format_dxt3_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 211 {
 212    uint8_t tmp[4];
 213    util_format_dxt3_rgba_fetch(0, src, i, j, tmp);
 214    dst[0] = ubyte_to_float(tmp[0]);
 215    dst[1] = ubyte_to_float(tmp[1]);
 216    dst[2] = ubyte_to_float(tmp[2]);
 217    dst[3] = ubyte_to_float(tmp[3]);
 218 }
 219
 220 void
 221 util_format_dxt5_rgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 222 {
 223    uint8_t tmp[4];
 224    util_format_dxt5_rgba_fetch(0, src, i, j, tmp);
 225    dst[0] = ubyte_to_float(tmp[0]);
 226    dst[1] = ubyte_to_float(tmp[1]);
 227    dst[2] = ubyte_to_float(tmp[2]);
 228    dst[3] = ubyte_to_float(tmp[3]);
 229 }
 230
 231
 232 /*
 233  * Block decompression.
 234  */
 235
 236 static INLINE void
 237 util_format_dxtn_rgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 238                                         const uint8_t *src_row, unsigned src_stride,
 239                                         unsigned width, unsigned height,
 240                                         util_format_dxtn_fetch_t fetch,
 241                                         unsigned block_size)
 242 {
 243    const unsigned bw = 4, bh = 4, comps = 4;
 244    unsigned x, y, i, j;
 245    for(y = 0; y < height; y += bh) {
 246       const uint8_t *src = src_row;
 247       for(x = 0; x < width; x += bw) {
 248          for(j = 0; j < bh; ++j) {
 249             for(i = 0; i < bw; ++i) {
 250                uint8_t *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*comps;
 251                fetch(0, src, i, j, dst);
 252             }
 253          }
 254          src += block_size;
 255       }
 256       src_row += src_stride;
 257    }
 258 }
 259
 260 void
 261 util_format_dxt1_rgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 262                                         const uint8_t *src_row, unsigned src_stride,
 263                                         unsigned width, unsigned height)
 264 {
 265    util_format_dxtn_rgb_unpack_rgba_8unorm(dst_row, dst_stride,
 266                                            src_row, src_stride,
 267                                            width, height,
 268                                            util_format_dxt1_rgb_fetch, 8);
 269 }
 270
 271 void
 272 util_format_dxt1_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 273                                          const uint8_t *src_row, unsigned src_stride,
 274                                          unsigned width, unsigned height)
 275 {
 276    util_format_dxtn_rgb_unpack_rgba_8unorm(dst_row, dst_stride,
 277                                            src_row, src_stride,
 278                                            width, height,
 279                                            util_format_dxt1_rgba_fetch, 8);
 280 }
 281
 282 void
 283 util_format_dxt3_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 284                                          const uint8_t *src_row, unsigned src_stride,
 285                                          unsigned width, unsigned height)
 286 {
 287    util_format_dxtn_rgb_unpack_rgba_8unorm(dst_row, dst_stride,
 288                                            src_row, src_stride,
 289                                            width, height,
 290                                            util_format_dxt3_rgba_fetch, 16);
 291 }
 292
 293 void
 294 util_format_dxt5_rgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 295                                          const uint8_t *src_row, unsigned src_stride,
 296                                          unsigned width, unsigned height)
 297 {
 298    util_format_dxtn_rgb_unpack_rgba_8unorm(dst_row, dst_stride,
 299                                            src_row, src_stride,
 300                                            width, height,
 301                                            util_format_dxt5_rgba_fetch, 16);
 302 }
 303
 304 static INLINE void
 305 util_format_dxtn_rgb_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 306                                        const uint8_t *src_row, unsigned src_stride,
 307                                        unsigned width, unsigned height,
 308                                        util_format_dxtn_fetch_t fetch,
 309                                        unsigned block_size)
 310 {
 311    unsigned x, y, i, j;
 312    for(y = 0; y < height; y += 4) {
 313       const uint8_t *src = src_row;
 314       for(x = 0; x < width; x += 4) {
 315          for(j = 0; j < 4; ++j) {
 316             for(i = 0; i < 4; ++i) {
 317                float *dst = dst_row + (y + j)*dst_stride/sizeof(*dst_row) + (x + i)*4;
 318                uint8_t tmp[4];
 319                fetch(0, src, i, j, tmp);
 320                dst[0] = ubyte_to_float(tmp[0]);
 321                dst[1] = ubyte_to_float(tmp[1]);
 322                dst[2] = ubyte_to_float(tmp[2]);
 323                dst[3] = ubyte_to_float(tmp[3]);
 324             }
 325          }
 326          src += block_size;
 327       }
 328       src_row += src_stride;
 329    }
 330 }
 331
 332 void
 333 util_format_dxt1_rgb_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 334                                        const uint8_t *src_row, unsigned src_stride,
 335                                        unsigned width, unsigned height)
 336 {
 337    util_format_dxtn_rgb_unpack_rgba_float(dst_row, dst_stride,
 338                                           src_row, src_stride,
 339                                           width, height,
 340                                           util_format_dxt1_rgb_fetch, 8);
 341 }
 342
 343 void
 344 util_format_dxt1_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 345                                         const uint8_t *src_row, unsigned src_stride,
 346                                         unsigned width, unsigned height)
 347 {
 348    util_format_dxtn_rgb_unpack_rgba_float(dst_row, dst_stride,
 349                                           src_row, src_stride,
 350                                           width, height,
 351                                           util_format_dxt1_rgba_fetch, 8);
 352 }
 353
 354 void
 355 util_format_dxt3_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 356                                         const uint8_t *src_row, unsigned src_stride,
 357                                         unsigned width, unsigned height)
 358 {
 359    util_format_dxtn_rgb_unpack_rgba_float(dst_row, dst_stride,
 360                                           src_row, src_stride,
 361                                           width, height,
 362                                           util_format_dxt3_rgba_fetch, 16);
 363 }
 364
 365 void
 366 util_format_dxt5_rgba_unpack_rgba_float(float *dst_row, unsigned dst_stride,
 367                                         const uint8_t *src_row, unsigned src_stride,
 368                                         unsigned width, unsigned height)
 369 {
 370    util_format_dxtn_rgb_unpack_rgba_float(dst_row, dst_stride,
 371                                           src_row, src_stride,
 372                                           width, height,
 373                                           util_format_dxt5_rgba_fetch, 16);
 374 }
 375
 376
 377 /*
 378  * Block compression.
 379  */
 380
 381 void
 382 util_format_dxt1_rgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 383                                       const uint8_t *src, unsigned src_stride,
 384                                       unsigned width, unsigned height)
 385 {
 386    const unsigned bw = 4, bh = 4, bytes_per_block = 8;
 387    unsigned x, y, i, j, k;
 388    for(y = 0; y < height; y += bh) {
 389       uint8_t *dst = dst_row;
 390       for(x = 0; x < width; x += bw) {
 391          uint8_t tmp[4][4][3];  /* [bh][bw][comps] */
 392          for(j = 0; j < bh; ++j) {
 393             for(i = 0; i < bw; ++i) {
 394                for(k = 0; k < 3; ++k) {
 395                   tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + (x + i)*4 + k];
 396                }
 397             }
 398          }
 399          util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, 0);
 400          dst += bytes_per_block;
 401       }
 402       dst_row += dst_stride / sizeof(*dst_row);
 403    }
 404 }
 405
 406 void
 407 util_format_dxt1_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 408                                        const uint8_t *src, unsigned src_stride,
 409                                        unsigned width, unsigned height)
 410 {
 411    const unsigned bw = 4, bh = 4, comps = 4, bytes_per_block = 8;
 412    unsigned x, y, i, j, k;
 413    for(y = 0; y < height; y += bh) {
 414       uint8_t *dst = dst_row;
 415       for(x = 0; x < width; x += bw) {
 416          uint8_t tmp[4][4][4];  /* [bh][bw][comps] */
 417          for(j = 0; j < bh; ++j) {
 418             for(i = 0; i < bw; ++i) {
 419                for(k = 0; k < comps; ++k) {
 420                   tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + (x + i)*comps + k];
 421                }
 422             }
 423          }
 424          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, 0);
 425          dst += bytes_per_block;
 426       }
 427       dst_row += dst_stride / sizeof(*dst_row);
 428    }
 429 }
 430
 431 void
 432 util_format_dxt3_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 433                                        const uint8_t *src, unsigned src_stride,
 434                                        unsigned width, unsigned height)
 435 {
 436    const unsigned bw = 4, bh = 4, comps = 4, bytes_per_block = 16;
 437    unsigned x, y, i, j, k;
 438    for(y = 0; y < height; y += bh) {
 439       uint8_t *dst = dst_row;
 440       for(x = 0; x < width; x += bw) {
 441          uint8_t tmp[4][4][4];  /* [bh][bw][comps] */
 442          for(j = 0; j < bh; ++j) {
 443             for(i = 0; i < bw; ++i) {
 444                for(k = 0; k < comps; ++k) {
 445                   tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + (x + i)*comps + k];
 446                }
 447             }
 448          }
 449          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, 0);
 450          dst += bytes_per_block;
 451       }
 452       dst_row += dst_stride / sizeof(*dst_row);
 453    }
 454 }
 455
 456 void
 457 util_format_dxt5_rgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
 458                                        const uint8_t *src, unsigned src_stride,
 459                                        unsigned width, unsigned height)
 460 {
 461    const unsigned bw = 4, bh = 4, comps = 4, bytes_per_block = 16;
 462    unsigned x, y, i, j, k;
 463
 464    for(y = 0; y < height; y += bh) {
 465       uint8_t *dst = dst_row;
 466       for(x = 0; x < width; x += bw) {
 467          uint8_t tmp[4][4][4];  /* [bh][bw][comps] */
 468          for(j = 0; j < bh; ++j) {
 469             for(i = 0; i < bw; ++i) {
 470                for(k = 0; k < comps; ++k) {
 471                   tmp[j][i][k] = src[(y + j)*src_stride/sizeof(*src) + (x + i)*comps + k];
 472                }
 473             }
 474          }
 475          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, 0);
 476          dst += bytes_per_block;
 477       }
 478       dst_row += dst_stride / sizeof(*dst_row);
 479    }
 480 }
 481
 482 void
 483 util_format_dxt1_rgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 484                                      const float *src, unsigned src_stride,
 485                                      unsigned width, unsigned height)
 486 {
 487    unsigned x, y, i, j, k;
 488    for(y = 0; y < height; y += 4) {
 489       uint8_t *dst = dst_row;
 490       for(x = 0; x < width; x += 4) {
 491          uint8_t tmp[4][4][3];
 492          for(j = 0; j < 4; ++j) {
 493             for(i = 0; i < 4; ++i) {
 494                for(k = 0; k < 3; ++k) {
 495                   tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + (x+i)*4 + k]);
 496                }
 497             }
 498          }
 499          util_format_dxtn_pack(3, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGB, dst, 0);
 500          dst += 8;
 501       }
 502       dst_row += 4*dst_stride/sizeof(*dst_row);
 503    }
 504 }
 505
 506 void
 507 util_format_dxt1_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 508                                       const float *src, unsigned src_stride,
 509                                       unsigned width, unsigned height)
 510 {
 511    unsigned x, y, i, j, k;
 512    for(y = 0; y < height; y += 4) {
 513       uint8_t *dst = dst_row;
 514       for(x = 0; x < width; x += 4) {
 515          uint8_t tmp[4][4][4];
 516          for(j = 0; j < 4; ++j) {
 517             for(i = 0; i < 4; ++i) {
 518                for(k = 0; k < 4; ++k) {
 519                   tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + (x+i)*4 + k]);
 520                }
 521             }
 522          }
 523          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT1_RGBA, dst, 0);
 524          dst += 8;
 525       }
 526       dst_row += 4*dst_stride/sizeof(*dst_row);
 527    }
 528 }
 529
 530 void
 531 util_format_dxt3_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 532                                       const float *src, unsigned src_stride,
 533                                       unsigned width, unsigned height)
 534 {
 535    unsigned x, y, i, j, k;
 536    for(y = 0; y < height; y += 4) {
 537       uint8_t *dst = dst_row;
 538       for(x = 0; x < width; x += 4) {
 539          uint8_t tmp[4][4][4];
 540          for(j = 0; j < 4; ++j) {
 541             for(i = 0; i < 4; ++i) {
 542                for(k = 0; k < 4; ++k) {
 543                   tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + (x+i)*4 + k]);
 544                }
 545             }
 546          }
 547          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT3_RGBA, dst, 0);
 548          dst += 16;
 549       }
 550       dst_row += 4*dst_stride/sizeof(*dst_row);
 551    }
 552 }
 553
 554 void
 555 util_format_dxt5_rgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
 556                                       const float *src, unsigned src_stride,
 557                                       unsigned width, unsigned height)
 558 {
 559    unsigned x, y, i, j, k;
 560    for(y = 0; y < height; y += 4) {
 561       uint8_t *dst = dst_row;
 562       for(x = 0; x < width; x += 4) {
 563          uint8_t tmp[4][4][4];
 564          for(j = 0; j < 4; ++j) {
 565             for(i = 0; i < 4; ++i) {
 566                for(k = 0; k < 4; ++k) {
 567                   tmp[j][i][k] = float_to_ubyte(src[(y + j)*src_stride/sizeof(*src) + (x+i)*4 + k]);
 568                }
 569             }
 570          }
 571          util_format_dxtn_pack(4, 4, 4, &tmp[0][0][0], UTIL_FORMAT_DXT5_RGBA, dst, 0);
 572          dst += 16;
 573       }
 574       dst_row += 4*dst_stride/sizeof(*dst_row);
 575    }
 576 }
 577
 578
 579 /*
 580  * SRGB variants.
 581  *
 582  * FIXME: shunts to RGB for now
 583  */
 584
 585 void
 586 util_format_dxt1_srgb_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 587 {
 588    util_format_dxt1_rgb_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 589 }
 590
 591 void
 592 util_format_dxt1_srgb_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 593 {
 594    util_format_dxt1_rgb_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 595 }
 596
 597 void
 598 util_format_dxt1_srgb_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 599 {
 600    util_format_dxt1_rgb_fetch_rgba_8unorm(dst, src, i, j);
 601 }
 602
 603 void
 604 util_format_dxt1_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 605 {
 606    util_format_dxt1_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 607 }
 608
 609 void
 610 util_format_dxt1_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 611 {
 612    util_format_dxt1_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 613 }
 614
 615 void
 616 util_format_dxt1_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 617 {
 618    util_format_dxt1_rgba_fetch_rgba_8unorm(dst, src, i, j);
 619 }
 620
 621 void
 622 util_format_dxt3_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 623 {
 624    util_format_dxt3_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 625 }
 626
 627 void
 628 util_format_dxt3_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 629 {
 630    util_format_dxt3_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 631 }
 632
 633 void
 634 util_format_dxt3_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 635 {
 636    util_format_dxt3_rgba_fetch_rgba_8unorm(dst, src, i, j);
 637 }
 638
 639 void
 640 util_format_dxt5_srgba_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 641 {
 642    util_format_dxt5_rgba_unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 643 }
 644
 645 void
 646 util_format_dxt5_srgba_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 647 {
 648    util_format_dxt5_rgba_pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, width, height);
 649 }
 650
 651 void
 652 util_format_dxt5_srgba_fetch_rgba_8unorm(uint8_t *dst, const uint8_t *src, unsigned i, unsigned j)
 653 {
 654    util_format_dxt5_rgba_fetch_rgba_8unorm(dst, src, i, j);
 655 }
 656
 657 void
 658 util_format_dxt1_srgb_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 659 {
 660    util_format_dxt1_rgb_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 661 }
 662
 663 void
 664 util_format_dxt1_srgb_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 665 {
 666    util_format_dxt1_rgb_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 667 }
 668
 669 void
 670 util_format_dxt1_srgb_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 671 {
 672    util_format_dxt1_rgb_fetch_rgba_float(dst, src, i, j);
 673 }
 674
 675 void
 676 util_format_dxt1_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 677 {
 678    util_format_dxt1_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 679 }
 680
 681 void
 682 util_format_dxt1_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 683 {
 684    util_format_dxt1_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 685 }
 686
 687 void
 688 util_format_dxt1_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 689 {
 690    util_format_dxt1_rgba_fetch_rgba_float(dst, src, i, j);
 691 }
 692
 693 void
 694 util_format_dxt3_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 695 {
 696    util_format_dxt3_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 697 }
 698
 699 void
 700 util_format_dxt3_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 701 {
 702    util_format_dxt3_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 703 }
 704
 705 void
 706 util_format_dxt3_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 707 {
 708    util_format_dxt3_rgba_fetch_rgba_float(dst, src, i, j);
 709 }
 710
 711 void
 712 util_format_dxt5_srgba_unpack_rgba_float(float *dst_row, unsigned dst_stride, const uint8_t *src_row, unsigned src_stride, unsigned width, unsigned height)
 713 {
 714    util_format_dxt5_rgba_unpack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 715 }
 716
 717 void
 718 util_format_dxt5_srgba_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride, const float *src_row, unsigned src_stride, unsigned width, unsigned height)
 719 {
 720    util_format_dxt5_rgba_pack_rgba_float(dst_row, dst_stride, src_row, src_stride, width, height);
 721 }
 722
 723 void
 724 util_format_dxt5_srgba_fetch_rgba_float(float *dst, const uint8_t *src, unsigned i, unsigned j)
 725 {
 726    util_format_dxt5_rgba_fetch_rgba_float(dst, src, i, j);
 727 }
 728