"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/auxiliary/util/u_pack_color.h" (16 Sep 2020, 16675 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "u_pack_color.h" see the Fossies "Dox" file reference documentation.

    1 /**************************************************************************
    2  *
    3  * Copyright 2008 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  * @file
   30  * Functions to produce packed colors/Z from floats.
   31  */
   32 
   33 
   34 #ifndef U_PACK_COLOR_H
   35 #define U_PACK_COLOR_H
   36 
   37 
   38 #include "pipe/p_compiler.h"
   39 #include "pipe/p_format.h"
   40 #include "util/format/u_format.h"
   41 #include "util/u_math.h"
   42 
   43 
   44 /**
   45  * Helper union for packing pixel values.
   46  * Will often contain values in formats which are too complex to be described
   47  * in simple terms, hence might just effectively contain a number of bytes.
   48  * Must be big enough to hold data for all formats (currently 256 bits).
   49  */
   50 union util_color {
   51    ubyte ub;
   52    ushort us;
   53    uint ui[4];
   54    ushort h[4]; /* half float */
   55    float f[4];
   56    double d[4];
   57 };
   58 
   59 /**
   60  * Pack ubyte R,G,B,A into dest pixel.
   61  */
   62 static inline void
   63 util_pack_color_ub(ubyte r, ubyte g, ubyte b, ubyte a,
   64                    enum pipe_format format, union util_color *uc)
   65 {
   66    switch (format) {
   67    case PIPE_FORMAT_ABGR8888_UNORM:
   68       {
   69          uc->ui[0] = (r << 24) | (g << 16) | (b << 8) | a;
   70       }
   71       return;
   72    case PIPE_FORMAT_XBGR8888_UNORM:
   73       {
   74          uc->ui[0] = (r << 24) | (g << 16) | (b << 8) | 0xff;
   75       }
   76       return;
   77    case PIPE_FORMAT_BGRA8888_UNORM:
   78       {
   79          uc->ui[0] = (a << 24) | (r << 16) | (g << 8) | b;
   80       }
   81       return;
   82    case PIPE_FORMAT_BGRX8888_UNORM:
   83       {
   84          uc->ui[0] = (0xff << 24) | (r << 16) | (g << 8) | b;
   85       }
   86       return;
   87    case PIPE_FORMAT_ARGB8888_UNORM:
   88       {
   89          uc->ui[0] = (b << 24) | (g << 16) | (r << 8) | a;
   90       }
   91       return;
   92    case PIPE_FORMAT_XRGB8888_UNORM:
   93       {
   94          uc->ui[0] = (b << 24) | (g << 16) | (r << 8) | 0xff;
   95       }
   96       return;
   97    case PIPE_FORMAT_B5G6R5_UNORM:
   98       {
   99          uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);
  100       }
  101       return;
  102    case PIPE_FORMAT_B5G5R5X1_UNORM:
  103       {
  104          uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
  105       }
  106       return;
  107    case PIPE_FORMAT_B5G5R5A1_UNORM:
  108       {
  109          uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
  110       }
  111       return;
  112    case PIPE_FORMAT_B4G4R4A4_UNORM:
  113       {
  114          uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);
  115       }
  116       return;
  117    case PIPE_FORMAT_A8_UNORM:
  118       {
  119          uc->ub = a;
  120       }
  121       return;
  122    case PIPE_FORMAT_L8_UNORM:
  123    case PIPE_FORMAT_I8_UNORM:
  124       {
  125          uc->ub = r;
  126       }
  127       return;
  128    case PIPE_FORMAT_R32G32B32A32_FLOAT:
  129       {
  130          uc->f[0] = (float)r / 255.0f;
  131          uc->f[1] = (float)g / 255.0f;
  132          uc->f[2] = (float)b / 255.0f;
  133          uc->f[3] = (float)a / 255.0f;
  134       }
  135       return;
  136    case PIPE_FORMAT_R32G32B32_FLOAT:
  137       {
  138          uc->f[0] = (float)r / 255.0f;
  139          uc->f[1] = (float)g / 255.0f;
  140          uc->f[2] = (float)b / 255.0f;
  141       }
  142       return;
  143 
  144    /* Handle other cases with a generic function.
  145     */
  146    default:
  147       {
  148          ubyte src[4];
  149 
  150          src[0] = r;
  151          src[1] = g;
  152          src[2] = b;
  153          src[3] = a;
  154          util_format_write_4ub(format, src, 0, uc, 0, 0, 0, 1, 1);
  155       }
  156    }
  157 }
  158  
  159 
  160 /**
  161  * Unpack RGBA from a packed pixel, returning values as ubytes in [0,255].
  162  */
  163 static inline void
  164 util_unpack_color_ub(enum pipe_format format, union util_color *uc,
  165                      ubyte *r, ubyte *g, ubyte *b, ubyte *a)
  166 {
  167    switch (format) {
  168    case PIPE_FORMAT_ABGR8888_UNORM:
  169       {
  170          uint p = uc->ui[0];
  171          *r = (ubyte) ((p >> 24) & 0xff);
  172          *g = (ubyte) ((p >> 16) & 0xff);
  173          *b = (ubyte) ((p >>  8) & 0xff);
  174          *a = (ubyte) ((p >>  0) & 0xff);
  175       }
  176       return;
  177    case PIPE_FORMAT_XBGR8888_UNORM:
  178       {
  179          uint p = uc->ui[0];
  180          *r = (ubyte) ((p >> 24) & 0xff);
  181          *g = (ubyte) ((p >> 16) & 0xff);
  182          *b = (ubyte) ((p >>  8) & 0xff);
  183          *a = (ubyte) 0xff;
  184       }
  185       return;
  186    case PIPE_FORMAT_BGRA8888_UNORM:
  187       {
  188          uint p = uc->ui[0];
  189          *r = (ubyte) ((p >> 16) & 0xff);
  190          *g = (ubyte) ((p >>  8) & 0xff);
  191          *b = (ubyte) ((p >>  0) & 0xff);
  192          *a = (ubyte) ((p >> 24) & 0xff);
  193       }
  194       return;
  195    case PIPE_FORMAT_BGRX8888_UNORM:
  196       {
  197          uint p = uc->ui[0];
  198          *r = (ubyte) ((p >> 16) & 0xff);
  199          *g = (ubyte) ((p >>  8) & 0xff);
  200          *b = (ubyte) ((p >>  0) & 0xff);
  201          *a = (ubyte) 0xff;
  202       }
  203       return;
  204    case PIPE_FORMAT_ARGB8888_UNORM:
  205       {
  206          uint p = uc->ui[0];
  207          *r = (ubyte) ((p >>  8) & 0xff);
  208          *g = (ubyte) ((p >> 16) & 0xff);
  209          *b = (ubyte) ((p >> 24) & 0xff);
  210          *a = (ubyte) ((p >>  0) & 0xff);
  211       }
  212       return;
  213    case PIPE_FORMAT_XRGB8888_UNORM:
  214       {
  215          uint p = uc->ui[0];
  216          *r = (ubyte) ((p >>  8) & 0xff);
  217          *g = (ubyte) ((p >> 16) & 0xff);
  218          *b = (ubyte) ((p >> 24) & 0xff);
  219          *a = (ubyte) 0xff;
  220       }
  221       return;
  222    case PIPE_FORMAT_B5G6R5_UNORM:
  223       {
  224          ushort p = uc->us;
  225          *r = (ubyte) (((p >> 8) & 0xf8) | ((p >> 13) & 0x7));
  226          *g = (ubyte) (((p >> 3) & 0xfc) | ((p >>  9) & 0x3));
  227          *b = (ubyte) (((p << 3) & 0xf8) | ((p >>  2) & 0x7));
  228          *a = (ubyte) 0xff;
  229       }
  230       return;
  231    case PIPE_FORMAT_B5G5R5X1_UNORM:
  232       {
  233          ushort p = uc->us;
  234          *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));
  235          *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));
  236          *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));
  237          *a = (ubyte) 0xff;
  238       }
  239       return;
  240    case PIPE_FORMAT_B5G5R5A1_UNORM:
  241       {
  242          ushort p = uc->us;
  243          *r = (ubyte) (((p >>  7) & 0xf8) | ((p >> 12) & 0x7));
  244          *g = (ubyte) (((p >>  2) & 0xf8) | ((p >>  7) & 0x7));
  245          *b = (ubyte) (((p <<  3) & 0xf8) | ((p >>  2) & 0x7));
  246          *a = (ubyte) (0xff * (p >> 15));
  247       }
  248       return;
  249    case PIPE_FORMAT_B4G4R4A4_UNORM:
  250       {
  251          ushort p = uc->us;
  252          *r = (ubyte) (((p >> 4) & 0xf0) | ((p >>  8) & 0xf));
  253          *g = (ubyte) (((p >> 0) & 0xf0) | ((p >>  4) & 0xf));
  254          *b = (ubyte) (((p << 4) & 0xf0) | ((p >>  0) & 0xf));
  255          *a = (ubyte) (((p >> 8) & 0xf0) | ((p >> 12) & 0xf));
  256       }
  257       return;
  258    case PIPE_FORMAT_A8_UNORM:
  259       {
  260          ubyte p = uc->ub;
  261          *r = *g = *b = (ubyte) 0xff;
  262          *a = p;
  263       }
  264       return;
  265    case PIPE_FORMAT_L8_UNORM:
  266       {
  267          ubyte p = uc->ub;
  268          *r = *g = *b = p;
  269          *a = (ubyte) 0xff;
  270       }
  271       return;
  272    case PIPE_FORMAT_I8_UNORM:
  273       {
  274          ubyte p = uc->ub;
  275          *r = *g = *b = *a = p;
  276       }
  277       return;
  278    case PIPE_FORMAT_R32G32B32A32_FLOAT:
  279       {
  280          const float *p = &uc->f[0];
  281          *r = float_to_ubyte(p[0]);
  282          *g = float_to_ubyte(p[1]);
  283          *b = float_to_ubyte(p[2]);
  284          *a = float_to_ubyte(p[3]);
  285       }
  286       return;
  287    case PIPE_FORMAT_R32G32B32_FLOAT:
  288       {
  289          const float *p = &uc->f[0];
  290          *r = float_to_ubyte(p[0]);
  291          *g = float_to_ubyte(p[1]);
  292          *b = float_to_ubyte(p[2]);
  293          *a = (ubyte) 0xff;
  294       }
  295       return;
  296 
  297    case PIPE_FORMAT_R32G32_FLOAT:
  298       {
  299          const float *p = &uc->f[0];
  300          *r = float_to_ubyte(p[0]);
  301          *g = float_to_ubyte(p[1]);
  302          *b = *a = (ubyte) 0xff;
  303       }
  304       return;
  305 
  306    case PIPE_FORMAT_R32_FLOAT:
  307       {
  308          const float *p = &uc->f[0];
  309          *r = float_to_ubyte(p[0]);
  310          *g = *b = *a = (ubyte) 0xff;
  311       }
  312       return;
  313 
  314    /* Handle other cases with a generic function.
  315     */
  316    default:
  317       {
  318          ubyte dst[4];
  319 
  320          util_format_read_4ub(format, dst, 0, uc, 0, 0, 0, 1, 1);
  321          *r = dst[0];
  322          *g = dst[1];
  323          *b = dst[2];
  324          *a = dst[3];
  325       }
  326    }
  327 }
  328 
  329 
  330 /**
  331  * Note rgba outside [0,1] will be clamped for int pixel formats.
  332  * This will not work (and might not really be useful with float input)
  333  * for pure integer formats (which lack the pack_rgba_float function).
  334  */
  335 static inline void
  336 util_pack_color(const float rgba[4], enum pipe_format format, union util_color *uc)
  337 {
  338    ubyte r = 0;
  339    ubyte g = 0;
  340    ubyte b = 0;
  341    ubyte a = 0;
  342 
  343    if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0) <= 8) {
  344       /* format uses 8-bit components or less */
  345       r = float_to_ubyte(rgba[0]);
  346       g = float_to_ubyte(rgba[1]);
  347       b = float_to_ubyte(rgba[2]);
  348       a = float_to_ubyte(rgba[3]);
  349    }
  350 
  351    switch (format) {
  352    case PIPE_FORMAT_ABGR8888_UNORM:
  353       {
  354          uc->ui[0] = (r << 24) | (g << 16) | (b << 8) | a;
  355       }
  356       return;
  357    case PIPE_FORMAT_XBGR8888_UNORM:
  358       {
  359          uc->ui[0] = (r << 24) | (g << 16) | (b << 8) | 0xff;
  360       }
  361       return;
  362    case PIPE_FORMAT_BGRA8888_UNORM:
  363       {
  364          uc->ui[0] = (a << 24) | (r << 16) | (g << 8) | b;
  365       }
  366       return;
  367    case PIPE_FORMAT_BGRX8888_UNORM:
  368       {
  369          uc->ui[0] = (0xffu << 24) | (r << 16) | (g << 8) | b;
  370       }
  371       return;
  372    case PIPE_FORMAT_ARGB8888_UNORM:
  373       {
  374          uc->ui[0] = (b << 24) | (g << 16) | (r << 8) | a;
  375       }
  376       return;
  377    case PIPE_FORMAT_XRGB8888_UNORM:
  378       {
  379          uc->ui[0] = (b << 24) | (g << 16) | (r << 8) | 0xff;
  380       }
  381       return;
  382    case PIPE_FORMAT_B5G6R5_UNORM:
  383       {
  384          uc->us = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | (b >> 3);
  385       }
  386       return;
  387    case PIPE_FORMAT_B5G5R5X1_UNORM:
  388       {
  389          uc->us = ((0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
  390       }
  391       return;
  392    case PIPE_FORMAT_B5G5R5A1_UNORM:
  393       {
  394          uc->us = ((a & 0x80) << 8) | ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | (b >> 3);
  395       }
  396       return;
  397    case PIPE_FORMAT_B4G4R4A4_UNORM:
  398       {
  399          uc->us = ((a & 0xf0) << 8) | ((r & 0xf0) << 4) | ((g & 0xf0) << 0) | (b >> 4);
  400       }
  401       return;
  402    case PIPE_FORMAT_A8_UNORM:
  403       {
  404          uc->ub = a;
  405       }
  406       return;
  407    case PIPE_FORMAT_L8_UNORM:
  408    case PIPE_FORMAT_I8_UNORM:
  409       {
  410          uc->ub = r;
  411       }
  412       return;
  413    case PIPE_FORMAT_R32G32B32A32_FLOAT:
  414       {
  415          uc->f[0] = rgba[0];
  416          uc->f[1] = rgba[1];
  417          uc->f[2] = rgba[2];
  418          uc->f[3] = rgba[3];
  419       }
  420       return;
  421    case PIPE_FORMAT_R32G32B32_FLOAT:
  422       {
  423          uc->f[0] = rgba[0];
  424          uc->f[1] = rgba[1];
  425          uc->f[2] = rgba[2];
  426       }
  427       return;
  428 
  429    /* Handle other cases with a generic function.
  430     */
  431    default:
  432       util_format_pack_rgba(format, uc, rgba, 1);
  433    }
  434 }
  435 
  436 static inline void
  437 util_pack_color_union(enum pipe_format format,
  438                       union util_color *dst,
  439                       const union pipe_color_union *src)
  440 {
  441    util_format_pack_rgba(format, dst, &src->ui, 1);
  442 }
  443 
  444 /* Integer versions of util_pack_z and util_pack_z_stencil - useful for
  445  * constructing clear masks.
  446  */
  447 static inline uint32_t
  448 util_pack_mask_z(enum pipe_format format, uint32_t z)
  449 {
  450    switch (format) {
  451    case PIPE_FORMAT_Z16_UNORM:
  452       return z & 0xffff;
  453    case PIPE_FORMAT_Z32_UNORM:
  454    case PIPE_FORMAT_Z32_FLOAT:
  455       return z;
  456    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  457    case PIPE_FORMAT_Z24X8_UNORM:
  458       return z & 0xffffff;
  459    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  460    case PIPE_FORMAT_X8Z24_UNORM:
  461       return (z & 0xffffff) << 8;
  462    case PIPE_FORMAT_S8_UINT:
  463       return 0;
  464    default:
  465       debug_printf("gallium: unhandled format in util_pack_mask_z(): %s\n",
  466                    util_format_name(format));
  467       assert(0);
  468       return 0;
  469    }
  470 }
  471 
  472 
  473 static inline uint64_t
  474 util_pack64_mask_z(enum pipe_format format, uint32_t z)
  475 {
  476    switch (format) {
  477    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  478       return z;
  479    default:
  480       return util_pack_mask_z(format, z);
  481    }
  482 }
  483 
  484 
  485 static inline uint32_t
  486 util_pack_mask_z_stencil(enum pipe_format format, uint32_t z, uint8_t s)
  487 {
  488    uint32_t packed = util_pack_mask_z(format, z);
  489 
  490    switch (format) {
  491    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  492       packed |= (uint32_t)s << 24;
  493       break;
  494    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  495       packed |= s;
  496       break;
  497    case PIPE_FORMAT_S8_UINT:
  498       packed |= s;
  499       break;
  500    default:
  501       break;
  502    }
  503 
  504    return packed;
  505 }
  506 
  507 
  508 static inline uint64_t
  509 util_pack64_mask_z_stencil(enum pipe_format format, uint32_t z, uint8_t s)
  510 {
  511    uint64_t packed;
  512 
  513    switch (format) {
  514    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  515       packed = util_pack64_mask_z(format, z);
  516       packed |= (uint64_t)s << 32ull;
  517       return packed;
  518    default:
  519       return util_pack_mask_z_stencil(format, z, s);
  520    }
  521 }
  522 
  523 
  524 /**
  525  * Note: it's assumed that z is in [0,1]
  526  */
  527 static inline uint32_t
  528 util_pack_z(enum pipe_format format, double z)
  529 {
  530    union fi fui;
  531 
  532    if (z == 0.0)
  533       return 0;
  534 
  535    switch (format) {
  536    case PIPE_FORMAT_Z16_UNORM:
  537       if (z == 1.0)
  538          return 0xffff;
  539       return (uint32_t) lrint(z * 0xffff);
  540    case PIPE_FORMAT_Z32_UNORM:
  541       /* special-case to avoid overflow */
  542       if (z == 1.0)
  543          return 0xffffffff;
  544       return (uint32_t) llrint(z * 0xffffffff);
  545    case PIPE_FORMAT_Z32_FLOAT:
  546       fui.f = (float)z;
  547       return fui.ui;
  548    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  549    case PIPE_FORMAT_Z24X8_UNORM:
  550       if (z == 1.0)
  551          return 0xffffff;
  552       return (uint32_t) lrint(z * 0xffffff);
  553    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  554    case PIPE_FORMAT_X8Z24_UNORM:
  555       if (z == 1.0)
  556          return 0xffffff00;
  557       return ((uint32_t) lrint(z * 0xffffff)) << 8;
  558    case PIPE_FORMAT_S8_UINT:
  559       /* this case can get it via util_pack_z_stencil() */
  560       return 0;
  561    default:
  562       debug_printf("gallium: unhandled format in util_pack_z(): %s\n",
  563                    util_format_name(format));
  564       assert(0);
  565       return 0;
  566    }
  567 }
  568 
  569 
  570 static inline uint64_t
  571 util_pack64_z(enum pipe_format format, double z)
  572 {
  573    union fi fui;
  574 
  575    if (z == 0)
  576       return 0;
  577 
  578    switch (format) {
  579    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  580       fui.f = (float)z;
  581       return fui.ui;
  582    default:
  583       return util_pack_z(format, z);
  584    }
  585 }
  586  
  587 
  588 /**
  589  * Pack Z and/or stencil values into a 32-bit value described by format.
  590  * Note: it's assumed that z is in [0,1] and s in [0,255]
  591  */
  592 static inline uint32_t
  593 util_pack_z_stencil(enum pipe_format format, double z, uint8_t s)
  594 {
  595    uint32_t packed = util_pack_z(format, z);
  596 
  597    switch (format) {
  598    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
  599       packed |= (uint32_t)s << 24;
  600       break;
  601    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
  602       packed |= s;
  603       break;
  604    case PIPE_FORMAT_S8_UINT:
  605       packed |= s;
  606       break;
  607    default:
  608       break;
  609    }
  610 
  611    return packed;
  612 }
  613 
  614 
  615 static inline uint64_t
  616 util_pack64_z_stencil(enum pipe_format format, double z, uint8_t s)
  617 {
  618    uint64_t packed;
  619 
  620    switch (format) {
  621    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
  622       packed = util_pack64_z(format, z);
  623       packed |= (uint64_t)s << 32ull;
  624       break;
  625    default:
  626       return util_pack_z_stencil(format, z, s);
  627    }
  628 
  629    return packed;
  630 }
  631 
  632 
  633 /**
  634  * Pack 4 ubytes into a 4-byte word
  635  */
  636 static inline unsigned
  637 pack_ub4(ubyte b0, ubyte b1, ubyte b2, ubyte b3)
  638 {
  639    return ((((unsigned int)b0) << 0) |
  640        (((unsigned int)b1) << 8) |
  641        (((unsigned int)b2) << 16) |
  642        (((unsigned int)b3) << 24));
  643 }
  644 
  645 
  646 /**
  647  * Pack/convert 4 floats into one 4-byte word.
  648  */
  649 static inline unsigned
  650 pack_ui32_float4(float a, float b, float c, float d)
  651 {
  652    return pack_ub4( float_to_ubyte(a),
  653             float_to_ubyte(b),
  654             float_to_ubyte(c),
  655             float_to_ubyte(d) );
  656 }
  657 
  658 
  659 
  660 #endif /* U_PACK_COLOR_H */