src/gallium/drivers/swr/rasterizer/memory/Convert.h

   1 /****************************************************************************
   2 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21 * IN THE SOFTWARE.
  22 *
  23 * @file Convert.h
  24 *
  25 * @brief Conversion utility functions
  26 *
  27 ******************************************************************************/
  28 #pragma once
  29
  30 #if defined(_WIN32)
  31 // disable "potential divide by 0"
  32 #pragma warning(disable: 4723)
  33 #endif
  34
  35 //////////////////////////////////////////////////////////////////////////
  36 /// @brief Convert an IEEE 754 16-bit float to an 32-bit single precision
  37 ///        float
  38 /// @param val - 16-bit float
  39 /// @todo Maybe move this outside of this file into a header?
  40 static float ConvertSmallFloatTo32(UINT val)
  41 {
  42     UINT result;
  43     if ((val & 0x7fff) == 0)
  44     {
  45         result = ((uint32_t)(val & 0x8000)) << 16;
  46     }
  47     else if ((val & 0x7c00) == 0x7c00)
  48     {
  49         result = ((val & 0x3ff) == 0) ? 0x7f800000 : 0x7fc00000;
  50         result |= ((uint32_t)val & 0x8000) << 16;
  51     }
  52     else
  53     {
  54         uint32_t sign = (val & 0x8000) << 16;
  55         uint32_t mant = (val & 0x3ff) << 13;
  56         uint32_t exp = (val >> 10) & 0x1f;
  57         if ((exp == 0) && (mant != 0)) // Adjust exponent and mantissa for denormals
  58         {
  59             mant <<= 1;
  60             while (mant < (0x400 << 13))
  61             {
  62                 exp--;
  63                 mant <<= 1;
  64             }
  65             mant &= (0x3ff << 13);
  66         }
  67         exp = ((exp - 15 + 127) & 0xff) << 23;
  68         result = sign | exp | mant;
  69     }
  70
  71     return *(float*)&result;
  72 }
  73
  74 //////////////////////////////////////////////////////////////////////////
  75 /// @brief Convert an IEEE 754 32-bit single precision float to an
  76 ///        unsigned small float with 5 exponent bits and a variable
  77 ///        number of mantissa bits.
  78 /// @param val - 32-bit float
  79 /// @todo Maybe move this outside of this file into a header?
  80 template<UINT numMantissaBits>
  81 static UINT Convert32ToSmallFloat(float val)
  82 {
  83     uint32_t sign, exp, mant;
  84     uint32_t roundBits;
  85
  86     // Extract the sign, exponent, and mantissa
  87     UINT uf = *(UINT*)&val;
  88
  89     sign = (uf & 0x80000000) >> 31;
  90     exp = (uf & 0x7F800000) >> 23;
  91     mant = uf & 0x007FFFFF;
  92
  93     // 10/11 bit floats are unsigned.  Negative values are clamped to 0.
  94     if (sign != 0)
  95     {
  96         exp = mant = 0;
  97     }
  98     // Check for out of range
  99     else if ((exp == 0xFF) && (mant != 0)) // NaN
 100     {
 101         exp = 0x1F;
 102         mant = 1 << numMantissaBits;
 103     }
 104     else if ((exp == 0xFF) && (mant == 0)) // INF
 105     {
 106         exp = 0x1F;
 107         mant = 0;
 108     }
 109     else if (exp > (0x70 + 0x1E)) // Too big to represent
 110     {
 111         exp = 0x1Eu;
 112         mant = (1 << numMantissaBits) - 1;  // 0x3F for 6 bit mantissa.
 113     }
 114     else if ((exp <= 0x70) && (exp >= 0x66)) // It's a denorm
 115     {
 116         mant |= 0x00800000;
 117         for (; exp <= 0x70; mant >>= 1, exp++)
 118             ;
 119         exp = 0;
 120         mant = mant >> (23 - numMantissaBits);
 121     }
 122     else if (exp < 0x66) // Too small to represent -> Zero
 123     {
 124         exp = 0;
 125         mant = 0;
 126     }
 127     else
 128     {
 129         // Saves bits that will be shifted off for rounding
 130         roundBits = mant & 0x1FFFu;
 131         // convert exponent and mantissa to 16 bit format
 132         exp = exp - 0x70u;
 133         mant = mant >> (23 - numMantissaBits);
 134
 135         // Essentially RTZ, but round up if off by only 1 lsb
 136         if (roundBits == 0x1FFFu)
 137         {
 138             mant++;
 139             // check for overflow
 140             if ((mant & (0x3 << numMantissaBits)) != 0) // 0x60 = 0x3 << (num Mantissa Bits)
 141                 exp++;
 142             // make sure only the needed bits are used
 143             mant &= (1 << numMantissaBits) - 1;
 144         }
 145     }
 146
 147     UINT tmpVal = (exp << numMantissaBits) | mant;
 148     return tmpVal;
 149 }
 150
 151 #if KNOB_ARCH == KNOB_ARCH_AVX
 152 //////////////////////////////////////////////////////////////////////////
 153 /// @brief Convert an IEEE 754 32-bit single precision float to an
 154 ///        16 bit float with 5 exponent bits and a variable
 155 ///        number of mantissa bits.
 156 /// @param val - 32-bit float
 157 /// @todo Maybe move this outside of this file into a header?
 158 static uint16_t Convert32To16Float(float val)
 159 {
 160     uint32_t sign, exp, mant;
 161     uint32_t roundBits;
 162
 163     // Extract the sign, exponent, and mantissa
 164     uint32_t uf = *(uint32_t*)&val;
 165     sign = (uf & 0x80000000) >> 31;
 166     exp = (uf & 0x7F800000) >> 23;
 167     mant = uf & 0x007FFFFF;
 168
 169     // Check for out of range
 170     if (std::isnan(val))
 171     {
 172         exp = 0x1F;
 173         mant = 0x200;
 174         sign = 1;                     // set the sign bit for NANs
 175     }
 176     else if (std::isinf(val))
 177     {
 178         exp = 0x1f;
 179         mant = 0x0;
 180     }
 181     else if (exp > (0x70 + 0x1E)) // Too big to represent -> max representable value
 182     {
 183         exp = 0x1E;
 184         mant = 0x3FF;
 185     }
 186     else if ((exp <= 0x70) && (exp >= 0x66)) // It's a denorm
 187     {
 188         mant |= 0x00800000;
 189         for (; exp <= 0x70; mant >>= 1, exp++)
 190             ;
 191         exp = 0;
 192         mant = mant >> 13;
 193     }
 194     else if (exp < 0x66) // Too small to represent -> Zero
 195     {
 196         exp = 0;
 197         mant = 0;
 198     }
 199     else
 200     {
 201         // Saves bits that will be shifted off for rounding
 202         roundBits = mant & 0x1FFFu;
 203         // convert exponent and mantissa to 16 bit format
 204         exp = exp - 0x70;
 205         mant = mant >> 13;
 206
 207         // Essentially RTZ, but round up if off by only 1 lsb
 208         if (roundBits == 0x1FFFu)
 209         {
 210             mant++;
 211             // check for overflow
 212             if ((mant & 0xC00u) != 0)
 213                 exp++;
 214             // make sure only the needed bits are used
 215             mant &= 0x3FF;
 216         }
 217     }
 218
 219     uint32_t tmpVal = (sign << 15) | (exp << 10) | mant;
 220     return (uint16_t)tmpVal;
 221 }
 222 #endif
 223
 224 //////////////////////////////////////////////////////////////////////////
 225 /// @brief Retrieve color from hot tile source which is always float.
 226 /// @param pDstPixel - Pointer to destination pixel.
 227 /// @param srcPixel - Pointer to source pixel (pre-swizzled according to dest).
 228 template<SWR_FORMAT DstFormat>
 229 static void ConvertPixelFromFloat(
 230     BYTE* pDstPixel,
 231     const float srcPixel[4])
 232 {
 233     UINT outColor[4];  // typeless bits
 234
 235     // Store component
 236     for (UINT comp = 0; comp < FormatTraits<DstFormat>::numComps; ++comp)
 237     {
 238         SWR_TYPE type = FormatTraits<DstFormat>::GetType(comp);
 239
 240         float src = srcPixel[comp];
 241
 242         switch (type)
 243         {
 244         case SWR_TYPE_UNORM:
 245         {
 246             // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false.
 247             src = (src != src) ? 0.0f : src;
 248
 249             // Clamp [0, 1]
 250             src = std::max(src, 0.0f);
 251             src = std::min(src, 1.0f);
 252
 253             // SRGB
 254             if (FormatTraits<DstFormat>::isSRGB && comp != 3)
 255             {
 256                 src = (src <= 0.0031308f) ? (12.92f * src) : (1.055f * powf(src, (1.0f / 2.4f)) - 0.055f);
 257             }
 258
 259             // Float scale to integer scale.
 260             UINT scale = (1 << FormatTraits<DstFormat>::GetBPC(comp)) - 1;
 261             src = (float)scale * src;
 262             src = roundf(src);
 263             outColor[comp] = (UINT)src; // Drop fractional part.
 264             break;
 265         }
 266         case SWR_TYPE_SNORM:
 267         {
 268             SWR_ASSERT(!FormatTraits<DstFormat>::isSRGB);
 269
 270             // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false.
 271             src = (src != src) ? 0.0f : src;
 272
 273             // Clamp [-1, 1]
 274             src = std::max(src, -1.0f);
 275             src = std::min(src, 1.0f);
 276
 277             // Float scale to integer scale.
 278             UINT scale = (1 << (FormatTraits<DstFormat>::GetBPC(comp) - 1)) - 1;
 279             src = (float)scale * src;
 280
 281             // Round
 282             src += (src >= 0) ? 0.5f : -0.5f;
 283
 284             INT out = (INT)src;
 285
 286             outColor[comp] = *(UINT*)&out;
 287
 288             break;
 289         }
 290         case SWR_TYPE_UINT:
 291         {
 292             ///@note The *(UINT*)& is currently necessary as the hot tile appears to always be float.
 293             //       However, the number in the hot tile should be unsigned integer. So doing this
 294             //       to preserve bits intead of doing a float -> integer conversion.
 295             if (FormatTraits<DstFormat>::GetBPC(comp) == 32)
 296             {
 297                 outColor[comp] = *(UINT*)&src;
 298             }
 299             else
 300             {
 301                 outColor[comp] = *(UINT*)&src;
 302                 UINT max = (1 << FormatTraits<DstFormat>::GetBPC(comp)) - 1;  // 2^numBits - 1
 303
 304                 outColor[comp] = std::min(max, outColor[comp]);
 305             }
 306             break;
 307         }
 308         case SWR_TYPE_SINT:
 309         {
 310             if (FormatTraits<DstFormat>::GetBPC(comp) == 32)
 311             {
 312                 outColor[comp] = *(UINT*)&src;
 313             }
 314             else
 315             {
 316                 INT out = *(INT*)&src;  // Hot tile format is SINT?
 317                 INT max = (1 << (FormatTraits<DstFormat>::GetBPC(comp) - 1)) - 1;
 318                 INT min = -1 - max;
 319
 320                 ///@note The output is unsigned integer (bag of bits) and so performing
 321                 //       the clamping here based on range of output component. Also, manually adding
 322                 //       the sign bit in the appropriate spot. Maybe a better way?
 323                 out = std::max(out, min);
 324                 out = std::min(out, max);
 325
 326                 outColor[comp] = *(UINT*)&out;
 327             }
 328             break;
 329         }
 330         case SWR_TYPE_FLOAT:
 331         {
 332             if (FormatTraits<DstFormat>::GetBPC(comp) == 16)
 333             {
 334                 // Convert from 32-bit float to 16-bit float using _mm_cvtps_ph
 335                 // @todo 16bit float instruction support is orthogonal to avx support.  need to
 336                 // add check for F16C support instead.
 337 #if KNOB_ARCH == KNOB_ARCH_AVX2
 338                 __m128 src128 = _mm_set1_ps(src);
 339                 __m128i srci128 = _mm_cvtps_ph(src128, _MM_FROUND_TRUNC);
 340                 UINT value = _mm_extract_epi16(srci128, 0);
 341 #else
 342                 UINT value = Convert32To16Float(src);
 343 #endif
 344
 345                 outColor[comp] = value;
 346             }
 347             else if (FormatTraits<DstFormat>::GetBPC(comp) == 11)
 348             {
 349                 outColor[comp] = Convert32ToSmallFloat<6>(src);
 350             }
 351             else if (FormatTraits<DstFormat>::GetBPC(comp) == 10)
 352             {
 353                 outColor[comp] = Convert32ToSmallFloat<5>(src);
 354             }
 355             else
 356             {
 357                 outColor[comp] = *(UINT*)&src;
 358             }
 359
 360             break;
 361         }
 362         default:
 363             SWR_ASSERT(0);
 364             break;
 365         }
 366     }
 367
 368     typename FormatTraits<DstFormat>::FormatT* pPixel = (typename FormatTraits<DstFormat>::FormatT*)pDstPixel;
 369
 370     switch (FormatTraits<DstFormat>::numComps)
 371     {
 372     case 4:
 373         pPixel->a = outColor[3];
 374     case 3:
 375         pPixel->b = outColor[2];
 376     case 2:
 377         pPixel->g = outColor[1];
 378     case 1:
 379         pPixel->r = outColor[0];
 380         break;
 381     default:
 382         SWR_ASSERT(0);
 383     }
 384 }
 385
 386 //////////////////////////////////////////////////////////////////////////
 387 /// @brief Convert pixel in any format to float32
 388 /// @param pDstPixel - Pointer to destination pixel.
 389 /// @param srcPixel - Pointer to source pixel
 390 template<SWR_FORMAT SrcFormat>
 391 INLINE static void ConvertPixelToFloat(
 392     float dstPixel[4],
 393     const BYTE* pSrc)
 394 {
 395     UINT srcColor[4];  // typeless bits
 396
 397     // unpack src pixel
 398     typename FormatTraits<SrcFormat>::FormatT* pPixel = (typename FormatTraits<SrcFormat>::FormatT*)pSrc;
 399
 400     // apply format defaults
 401     for (uint32_t comp = 0; comp < 4; ++comp)
 402     {
 403         uint32_t def = FormatTraits<SrcFormat>::GetDefault(comp);
 404         dstPixel[comp] = *(float*)&def;
 405     }
 406
 407     // load format data
 408     switch (FormatTraits<SrcFormat>::numComps)
 409     {
 410     case 4:
 411         srcColor[3] = pPixel->a;
 412     case 3:
 413         srcColor[2] = pPixel->b;
 414     case 2:
 415         srcColor[1] = pPixel->g;
 416     case 1:
 417         srcColor[0] = pPixel->r;
 418         break;
 419     default:
 420         SWR_ASSERT(0);
 421     }
 422
 423     // Convert components
 424     for (UINT comp = 0; comp < FormatTraits<SrcFormat>::numComps; ++comp)
 425     {
 426         SWR_TYPE type = FormatTraits<SrcFormat>::GetType(comp);
 427
 428         UINT src = srcColor[comp];
 429
 430         switch (type)
 431         {
 432         case SWR_TYPE_UNORM:
 433         {
 434             float dst;
 435             if (FormatTraits<SrcFormat>::isSRGB && comp != 3)
 436             {
 437                 dst = *(float*)&srgb8Table[src];
 438             }
 439             else
 440             {
 441                 // component sizes > 16 must use fp divide to maintain ulp requirements
 442                 if (FormatTraits<SrcFormat>::GetBPC(comp) > 16)
 443                 {
 444                     dst = (float)src / (float)((1 << FormatTraits<SrcFormat>::GetBPC(comp)) - 1);
 445                 }
 446                 else
 447                 {
 448                     const float scale = (1.0f / (float)((1 << FormatTraits<SrcFormat>::GetBPC(comp)) - 1));
 449                     dst = (float)src * scale;
 450                 }
 451             }
 452             dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = dst;
 453             break;
 454         }
 455         case SWR_TYPE_SNORM:
 456         {
 457             SWR_ASSERT(!FormatTraits<SrcFormat>::isSRGB);
 458
 459             float dst;
 460             if (src == 0x10)
 461             {
 462                 dst = -1.0f;
 463             }
 464             else
 465             {
 466                 switch (FormatTraits<SrcFormat>::GetBPC(comp))
 467                 {
 468                 case 8:
 469                     dst = (float)((int8_t)src);
 470                     break;
 471                 case 16:
 472                     dst = (float)((int16_t)src);
 473                     break;
 474                 case 32:
 475                     dst = (float)((int32_t)src);
 476                     break;
 477                 default:
 478                     assert(0 && "attempted to load from SNORM with unsupported bpc");
 479                     dst = 0.0f;
 480                     break;
 481                 }
 482                 dst = dst * (1.0f / ((1 << (FormatTraits<SrcFormat>::GetBPC(comp) - 1)) - 1));
 483             }
 484             dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = dst;
 485             break;
 486         }
 487         case SWR_TYPE_UINT:
 488         {
 489             UINT dst = (UINT)src;
 490             dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst;
 491             break;
 492         }
 493         case SWR_TYPE_SINT:
 494         {
 495             int dst;
 496             switch (FormatTraits<SrcFormat>::GetBPC(comp))
 497             {
 498             case 8:
 499                 dst = (int8_t)src;
 500                 break;
 501             case 16:
 502                 dst = (int16_t)src;
 503                 break;
 504             case 32:
 505                 dst = (int32_t)src;
 506                 break;
 507             default:
 508                 assert(0 && "attempted to load from SINT with unsupported bpc");
 509                 dst = 0;
 510                 break;
 511             }
 512             dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst;
 513             break;
 514         }
 515         case SWR_TYPE_FLOAT:
 516         {
 517             float dst;
 518             if (FormatTraits<SrcFormat>::GetBPC(comp) == 16)
 519             {
 520 #if KNOB_ARCH == KNOB_ARCH_AVX2
 521                 // Convert from 16-bit float to 32-bit float using _mm_cvtph_ps
 522                 // @todo 16bit float instruction support is orthogonal to avx support.  need to
 523                 // add check for F16C support instead.
 524                 __m128i src128 = _mm_set1_epi32(src);
 525                 __m128 res = _mm_cvtph_ps(src128);
 526                 _mm_store_ss(&dst, res);
 527 #else
 528                 dst = ConvertSmallFloatTo32(src);
 529 #endif
 530             }
 531             else if (FormatTraits<SrcFormat>::GetBPC(comp) == 11)
 532             {
 533                 dst = ConvertSmallFloatTo32(src << 4);
 534             }
 535             else if (FormatTraits<SrcFormat>::GetBPC(comp) == 10)
 536             {
 537                 dst = ConvertSmallFloatTo32(src << 5);
 538             }
 539             else
 540             {
 541                 dst = *(float*)&src;
 542             }
 543
 544             dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst;
 545             break;
 546         }
 547         default:
 548             SWR_ASSERT(0);
 549             break;
 550         }
 551     }
 552 }
 553
 554 // non-templated version of conversion functions
 555 INLINE static void ConvertPixelFromFloat(
 556     SWR_FORMAT format,
 557     uint8_t* pDst,
 558     const float srcPixel[4])
 559 {
 560     switch (format)
 561     {
 562     case R32G32B32A32_FLOAT: ConvertPixelFromFloat<R32G32B32A32_FLOAT>(pDst, srcPixel); break;
 563     case R32G32B32A32_SINT: ConvertPixelFromFloat<R32G32B32A32_SINT>(pDst, srcPixel); break;
 564     case R32G32B32A32_UINT: ConvertPixelFromFloat<R32G32B32A32_UINT>(pDst, srcPixel); break;
 565     case R32G32B32X32_FLOAT: ConvertPixelFromFloat<R32G32B32X32_FLOAT>(pDst, srcPixel); break;
 566     case R32G32B32A32_SSCALED: ConvertPixelFromFloat<R32G32B32A32_SSCALED>(pDst, srcPixel); break;
 567     case R32G32B32A32_USCALED: ConvertPixelFromFloat<R32G32B32A32_USCALED>(pDst, srcPixel); break;
 568     case R32G32B32_FLOAT: ConvertPixelFromFloat<R32G32B32_FLOAT>(pDst, srcPixel); break;
 569     case R32G32B32_SINT: ConvertPixelFromFloat<R32G32B32_SINT>(pDst, srcPixel); break;
 570     case R32G32B32_UINT: ConvertPixelFromFloat<R32G32B32_UINT>(pDst, srcPixel); break;
 571     case R32G32B32_SSCALED: ConvertPixelFromFloat<R32G32B32_SSCALED>(pDst, srcPixel); break;
 572     case R32G32B32_USCALED: ConvertPixelFromFloat<R32G32B32_USCALED>(pDst, srcPixel); break;
 573     case R16G16B16A16_UNORM: ConvertPixelFromFloat<R16G16B16A16_UNORM>(pDst, srcPixel); break;
 574     case R16G16B16A16_SNORM: ConvertPixelFromFloat<R16G16B16A16_SNORM>(pDst, srcPixel); break;
 575     case R16G16B16A16_SINT: ConvertPixelFromFloat<R16G16B16A16_SINT>(pDst, srcPixel); break;
 576     case R16G16B16A16_UINT: ConvertPixelFromFloat<R16G16B16A16_UINT>(pDst, srcPixel); break;
 577     case R16G16B16A16_FLOAT: ConvertPixelFromFloat<R16G16B16A16_FLOAT>(pDst, srcPixel); break;
 578     case R32G32_FLOAT: ConvertPixelFromFloat<R32G32_FLOAT>(pDst, srcPixel); break;
 579     case R32G32_SINT: ConvertPixelFromFloat<R32G32_SINT>(pDst, srcPixel); break;
 580     case R32G32_UINT: ConvertPixelFromFloat<R32G32_UINT>(pDst, srcPixel); break;
 581     case R32_FLOAT_X8X24_TYPELESS: ConvertPixelFromFloat<R32_FLOAT_X8X24_TYPELESS>(pDst, srcPixel); break;
 582     case R16G16B16X16_UNORM: ConvertPixelFromFloat<R16G16B16X16_UNORM>(pDst, srcPixel); break;
 583     case R16G16B16X16_FLOAT: ConvertPixelFromFloat<R16G16B16X16_FLOAT>(pDst, srcPixel); break;
 584     case R16G16B16A16_SSCALED: ConvertPixelFromFloat<R16G16B16A16_SSCALED>(pDst, srcPixel); break;
 585     case R16G16B16A16_USCALED: ConvertPixelFromFloat<R16G16B16A16_USCALED>(pDst, srcPixel); break;
 586     case R32G32_SSCALED: ConvertPixelFromFloat<R32G32_SSCALED>(pDst, srcPixel); break;
 587     case R32G32_USCALED: ConvertPixelFromFloat<R32G32_USCALED>(pDst, srcPixel); break;
 588     case R32_FLOAT_X8X24_TYPELESS_LD: ConvertPixelFromFloat<R32_FLOAT_X8X24_TYPELESS_LD>(pDst, srcPixel); break;
 589     case B8G8R8A8_UNORM: ConvertPixelFromFloat<B8G8R8A8_UNORM>(pDst, srcPixel); break;
 590     case B8G8R8A8_UNORM_SRGB: ConvertPixelFromFloat<B8G8R8A8_UNORM_SRGB>(pDst, srcPixel); break;
 591     case R10G10B10A2_UNORM: ConvertPixelFromFloat<R10G10B10A2_UNORM>(pDst, srcPixel); break;
 592     case R10G10B10A2_UNORM_SRGB: ConvertPixelFromFloat<R10G10B10A2_UNORM_SRGB>(pDst, srcPixel); break;
 593     case R10G10B10A2_UINT: ConvertPixelFromFloat<R10G10B10A2_UINT>(pDst, srcPixel); break;
 594     case R8G8B8A8_UNORM: ConvertPixelFromFloat<R8G8B8A8_UNORM>(pDst, srcPixel); break;
 595     case R8G8B8A8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8A8_UNORM_SRGB>(pDst, srcPixel); break;
 596     case R8G8B8A8_SNORM: ConvertPixelFromFloat<R8G8B8A8_SNORM>(pDst, srcPixel); break;
 597     case R8G8B8A8_SINT: ConvertPixelFromFloat<R8G8B8A8_SINT>(pDst, srcPixel); break;
 598     case R8G8B8A8_UINT: ConvertPixelFromFloat<R8G8B8A8_UINT>(pDst, srcPixel); break;
 599     case R16G16_UNORM: ConvertPixelFromFloat<R16G16_UNORM>(pDst, srcPixel); break;
 600     case R16G16_SNORM: ConvertPixelFromFloat<R16G16_SNORM>(pDst, srcPixel); break;
 601     case R16G16_SINT: ConvertPixelFromFloat<R16G16_SINT>(pDst, srcPixel); break;
 602     case R16G16_UINT: ConvertPixelFromFloat<R16G16_UINT>(pDst, srcPixel); break;
 603     case R16G16_FLOAT: ConvertPixelFromFloat<R16G16_FLOAT>(pDst, srcPixel); break;
 604     case B10G10R10A2_UNORM: ConvertPixelFromFloat<B10G10R10A2_UNORM>(pDst, srcPixel); break;
 605     case B10G10R10A2_UNORM_SRGB: ConvertPixelFromFloat<B10G10R10A2_UNORM_SRGB>(pDst, srcPixel); break;
 606     case R11G11B10_FLOAT: ConvertPixelFromFloat<R11G11B10_FLOAT>(pDst, srcPixel); break;
 607     case R32_SINT: ConvertPixelFromFloat<R32_SINT>(pDst, srcPixel); break;
 608     case R32_UINT: ConvertPixelFromFloat<R32_UINT>(pDst, srcPixel); break;
 609     case R32_FLOAT: ConvertPixelFromFloat<R32_FLOAT>(pDst, srcPixel); break;
 610     case R24_UNORM_X8_TYPELESS: ConvertPixelFromFloat<R24_UNORM_X8_TYPELESS>(pDst, srcPixel); break;
 611     case R24_UNORM_X8_TYPELESS_LD: ConvertPixelFromFloat<R24_UNORM_X8_TYPELESS_LD>(pDst, srcPixel); break;
 612     case A32_FLOAT: ConvertPixelFromFloat<A32_FLOAT>(pDst, srcPixel); break;
 613     case B8G8R8X8_UNORM: ConvertPixelFromFloat<B8G8R8X8_UNORM>(pDst, srcPixel); break;
 614     case B8G8R8X8_UNORM_SRGB: ConvertPixelFromFloat<B8G8R8X8_UNORM_SRGB>(pDst, srcPixel); break;
 615     case R8G8B8X8_UNORM: ConvertPixelFromFloat<R8G8B8X8_UNORM>(pDst, srcPixel); break;
 616     case R8G8B8X8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8X8_UNORM_SRGB>(pDst, srcPixel); break;
 617     case R9G9B9E5_SHAREDEXP: ConvertPixelFromFloat<R9G9B9E5_SHAREDEXP>(pDst, srcPixel); break;
 618     case B10G10R10X2_UNORM: ConvertPixelFromFloat<B10G10R10X2_UNORM>(pDst, srcPixel); break;
 619     case R10G10B10X2_USCALED: ConvertPixelFromFloat<R10G10B10X2_USCALED>(pDst, srcPixel); break;
 620     case R8G8B8A8_SSCALED: ConvertPixelFromFloat<R8G8B8A8_SSCALED>(pDst, srcPixel); break;
 621     case R8G8B8A8_USCALED: ConvertPixelFromFloat<R8G8B8A8_USCALED>(pDst, srcPixel); break;
 622     case R16G16_SSCALED: ConvertPixelFromFloat<R16G16_SSCALED>(pDst, srcPixel); break;
 623     case R16G16_USCALED: ConvertPixelFromFloat<R16G16_USCALED>(pDst, srcPixel); break;
 624     case R32_SSCALED: ConvertPixelFromFloat<R32_SSCALED>(pDst, srcPixel); break;
 625     case R32_USCALED: ConvertPixelFromFloat<R32_USCALED>(pDst, srcPixel); break;
 626     case B5G6R5_UNORM: ConvertPixelFromFloat<B5G6R5_UNORM>(pDst, srcPixel); break;
 627     case B5G6R5_UNORM_SRGB: ConvertPixelFromFloat<B5G6R5_UNORM_SRGB>(pDst, srcPixel); break;
 628     case B5G5R5A1_UNORM: ConvertPixelFromFloat<B5G5R5A1_UNORM>(pDst, srcPixel); break;
 629     case B5G5R5A1_UNORM_SRGB: ConvertPixelFromFloat<B5G5R5A1_UNORM_SRGB>(pDst, srcPixel); break;
 630     case B4G4R4A4_UNORM: ConvertPixelFromFloat<B4G4R4A4_UNORM>(pDst, srcPixel); break;
 631     case B4G4R4A4_UNORM_SRGB: ConvertPixelFromFloat<B4G4R4A4_UNORM_SRGB>(pDst, srcPixel); break;
 632     case R8G8_UNORM: ConvertPixelFromFloat<R8G8_UNORM>(pDst, srcPixel); break;
 633     case R8G8_SNORM: ConvertPixelFromFloat<R8G8_SNORM>(pDst, srcPixel); break;
 634     case R8G8_SINT: ConvertPixelFromFloat<R8G8_SINT>(pDst, srcPixel); break;
 635     case R8G8_UINT: ConvertPixelFromFloat<R8G8_UINT>(pDst, srcPixel); break;
 636     case R16_UNORM: ConvertPixelFromFloat<R16_UNORM>(pDst, srcPixel); break;
 637     case R16_SNORM: ConvertPixelFromFloat<R16_SNORM>(pDst, srcPixel); break;
 638     case R16_SINT: ConvertPixelFromFloat<R16_SINT>(pDst, srcPixel); break;
 639     case R16_UINT: ConvertPixelFromFloat<R16_UINT>(pDst, srcPixel); break;
 640     case R16_FLOAT: ConvertPixelFromFloat<R16_FLOAT>(pDst, srcPixel); break;
 641     case A16_UNORM: ConvertPixelFromFloat<A16_UNORM>(pDst, srcPixel); break;
 642     case A16_FLOAT: ConvertPixelFromFloat<A16_FLOAT>(pDst, srcPixel); break;
 643     case B5G5R5X1_UNORM: ConvertPixelFromFloat<B5G5R5X1_UNORM>(pDst, srcPixel); break;
 644     case B5G5R5X1_UNORM_SRGB: ConvertPixelFromFloat<B5G5R5X1_UNORM_SRGB>(pDst, srcPixel); break;
 645     case R8G8_SSCALED: ConvertPixelFromFloat<R8G8_SSCALED>(pDst, srcPixel); break;
 646     case R8G8_USCALED: ConvertPixelFromFloat<R8G8_USCALED>(pDst, srcPixel); break;
 647     case R16_SSCALED: ConvertPixelFromFloat<R16_SSCALED>(pDst, srcPixel); break;
 648     case R16_USCALED: ConvertPixelFromFloat<R16_USCALED>(pDst, srcPixel); break;
 649     case R8_UNORM: ConvertPixelFromFloat<R8_UNORM>(pDst, srcPixel); break;
 650     case R8_SNORM: ConvertPixelFromFloat<R8_SNORM>(pDst, srcPixel); break;
 651     case R8_SINT: ConvertPixelFromFloat<R8_SINT>(pDst, srcPixel); break;
 652     case R8_UINT: ConvertPixelFromFloat<R8_UINT>(pDst, srcPixel); break;
 653     case A8_UNORM: ConvertPixelFromFloat<A8_UNORM>(pDst, srcPixel); break;
 654     case R8_SSCALED: ConvertPixelFromFloat<R8_SSCALED>(pDst, srcPixel); break;
 655     case R8_USCALED: ConvertPixelFromFloat<R8_USCALED>(pDst, srcPixel); break;
 656     case YCRCB_SWAPUVY: ConvertPixelFromFloat<YCRCB_SWAPUVY>(pDst, srcPixel); break;
 657     case BC1_UNORM: ConvertPixelFromFloat<BC1_UNORM>(pDst, srcPixel); break;
 658     case BC2_UNORM: ConvertPixelFromFloat<BC2_UNORM>(pDst, srcPixel); break;
 659     case BC3_UNORM: ConvertPixelFromFloat<BC3_UNORM>(pDst, srcPixel); break;
 660     case BC4_UNORM: ConvertPixelFromFloat<BC4_UNORM>(pDst, srcPixel); break;
 661     case BC5_UNORM: ConvertPixelFromFloat<BC5_UNORM>(pDst, srcPixel); break;
 662     case BC1_UNORM_SRGB: ConvertPixelFromFloat<BC1_UNORM_SRGB>(pDst, srcPixel); break;
 663     case BC2_UNORM_SRGB: ConvertPixelFromFloat<BC2_UNORM_SRGB>(pDst, srcPixel); break;
 664     case BC3_UNORM_SRGB: ConvertPixelFromFloat<BC3_UNORM_SRGB>(pDst, srcPixel); break;
 665     case YCRCB_SWAPUV: ConvertPixelFromFloat<YCRCB_SWAPUV>(pDst, srcPixel); break;
 666     case R8G8B8_UNORM: ConvertPixelFromFloat<R8G8B8_UNORM>(pDst, srcPixel); break;
 667     case R8G8B8_SNORM: ConvertPixelFromFloat<R8G8B8_SNORM>(pDst, srcPixel); break;
 668     case R8G8B8_SSCALED: ConvertPixelFromFloat<R8G8B8_SSCALED>(pDst, srcPixel); break;
 669     case R8G8B8_USCALED: ConvertPixelFromFloat<R8G8B8_USCALED>(pDst, srcPixel); break;
 670     case BC4_SNORM: ConvertPixelFromFloat<BC4_SNORM>(pDst, srcPixel); break;
 671     case BC5_SNORM: ConvertPixelFromFloat<BC5_SNORM>(pDst, srcPixel); break;
 672     case R16G16B16_FLOAT: ConvertPixelFromFloat<R16G16B16_FLOAT>(pDst, srcPixel); break;
 673     case R16G16B16_UNORM: ConvertPixelFromFloat<R16G16B16_UNORM>(pDst, srcPixel); break;
 674     case R16G16B16_SNORM: ConvertPixelFromFloat<R16G16B16_SNORM>(pDst, srcPixel); break;
 675     case R16G16B16_SSCALED: ConvertPixelFromFloat<R16G16B16_SSCALED>(pDst, srcPixel); break;
 676     case R16G16B16_USCALED: ConvertPixelFromFloat<R16G16B16_USCALED>(pDst, srcPixel); break;
 677     case BC7_UNORM: ConvertPixelFromFloat<BC7_UNORM>(pDst, srcPixel); break;
 678     case BC7_UNORM_SRGB: ConvertPixelFromFloat<BC7_UNORM_SRGB>(pDst, srcPixel); break;
 679     case R8G8B8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8_UNORM_SRGB>(pDst, srcPixel); break;
 680     case R16G16B16_UINT: ConvertPixelFromFloat<R16G16B16_UINT>(pDst, srcPixel); break;
 681     case R16G16B16_SINT: ConvertPixelFromFloat<R16G16B16_SINT>(pDst, srcPixel); break;
 682     case R10G10B10A2_SNORM: ConvertPixelFromFloat<R10G10B10A2_SNORM>(pDst, srcPixel); break;
 683     case R10G10B10A2_USCALED: ConvertPixelFromFloat<R10G10B10A2_USCALED>(pDst, srcPixel); break;
 684     case R10G10B10A2_SSCALED: ConvertPixelFromFloat<R10G10B10A2_SSCALED>(pDst, srcPixel); break;
 685     case R10G10B10A2_SINT: ConvertPixelFromFloat<R10G10B10A2_SINT>(pDst, srcPixel); break;
 686     case B10G10R10A2_SNORM: ConvertPixelFromFloat<B10G10R10A2_SNORM>(pDst, srcPixel); break;
 687     case B10G10R10A2_USCALED: ConvertPixelFromFloat<B10G10R10A2_USCALED>(pDst, srcPixel); break;
 688     case B10G10R10A2_SSCALED: ConvertPixelFromFloat<B10G10R10A2_SSCALED>(pDst, srcPixel); break;
 689     case B10G10R10A2_UINT: ConvertPixelFromFloat<B10G10R10A2_UINT>(pDst, srcPixel); break;
 690     case B10G10R10A2_SINT: ConvertPixelFromFloat<B10G10R10A2_SINT>(pDst, srcPixel); break;
 691     case R8G8B8_UINT: ConvertPixelFromFloat<R8G8B8_UINT>(pDst, srcPixel); break;
 692     case R8G8B8_SINT: ConvertPixelFromFloat<R8G8B8_SINT>(pDst, srcPixel); break;
 693     default:
 694         break;
 695     }
 696 }
 697
 698