Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (c) 2011 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.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22.  * OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25.  
  26. /**
  27.  * Color, depth, stencil packing functions.
  28.  * Used to pack basic color, depth and stencil formats to specific
  29.  * hardware formats.
  30.  *
  31.  * There are both per-pixel and per-row packing functions:
  32.  * - The former will be used by swrast to write values to the color, depth,
  33.  *   stencil buffers when drawing points, lines and masked spans.
  34.  * - The later will be used for image-oriented functions like glDrawPixels,
  35.  *   glAccum, and glTexImage.
  36.  */
  37.  
  38.  
  39. #include "colormac.h"
  40. #include "format_pack.h"
  41. #include "macros.h"
  42. #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  43. #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  44.  
  45.  
  46. /** Helper struct for MESA_FORMAT_Z32_FLOAT_X24S8 */
  47. struct z32f_x24s8
  48. {
  49.    float z;
  50.    uint32_t x24s8;
  51. };
  52.  
  53.  
  54. typedef void (*pack_ubyte_rgba_row_func)(GLuint n,
  55.                                          const GLubyte src[][4], void *dst);
  56.  
  57. typedef void (*pack_float_rgba_row_func)(GLuint n,
  58.                                          const GLfloat src[][4], void *dst);
  59.  
  60.  
  61.  
  62. static inline GLfloat
  63. linear_to_srgb(GLfloat cl)
  64. {
  65.    if (cl < 0.0f)
  66.       return 0.0f;
  67.    else if (cl < 0.0031308f)
  68.       return 12.92f * cl;
  69.    else if (cl < 1.0f)
  70.       return 1.055f * powf(cl, 0.41666f) - 0.055f;
  71.    else
  72.       return 1.0f;
  73. }
  74.  
  75.  
  76. static inline GLubyte
  77. linear_float_to_srgb_ubyte(GLfloat cl)
  78. {
  79.    GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl));
  80.    return res;
  81. }
  82.  
  83.  
  84. static inline GLubyte
  85. linear_ubyte_to_srgb_ubyte(GLubyte cl)
  86. {
  87.    GLubyte res = FLOAT_TO_UBYTE(linear_to_srgb(cl / 255.0f));
  88.    return res;
  89. }
  90.  
  91.  
  92.  
  93.  
  94. /*
  95.  * MESA_FORMAT_RGBA8888
  96.  */
  97.  
  98. static void
  99. pack_ubyte_RGBA8888(const GLubyte src[4], void *dst)
  100. {
  101.    GLuint *d = ((GLuint *) dst);
  102.    *d = PACK_COLOR_8888(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
  103. }
  104.  
  105. static void
  106. pack_float_RGBA8888(const GLfloat src[4], void *dst)
  107. {
  108.    GLubyte v[4];
  109.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  110.    pack_ubyte_RGBA8888(v, dst);
  111. }
  112.  
  113. static void
  114. pack_row_ubyte_RGBA8888(GLuint n, const GLubyte src[][4], void *dst)
  115. {
  116.    GLuint *d = ((GLuint *) dst);
  117.    GLuint i;
  118.    for (i = 0; i < n; i++) {
  119.       d[i] = PACK_COLOR_8888(src[i][RCOMP], src[i][GCOMP],
  120.                              src[i][BCOMP], src[i][ACOMP]);
  121.    }
  122. }
  123.  
  124. static void
  125. pack_row_float_RGBA8888(GLuint n, const GLfloat src[][4], void *dst)
  126. {
  127.    GLuint *d = ((GLuint *) dst);
  128.    GLuint i;
  129.    for (i = 0; i < n; i++) {
  130.       GLubyte v[4];
  131.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  132.       pack_ubyte_RGBA8888(v, d + i);
  133.    }
  134. }
  135.  
  136.  
  137.  
  138. /*
  139.  * MESA_FORMAT_RGBA8888_REV
  140.  */
  141.  
  142. static void
  143. pack_ubyte_RGBA8888_REV(const GLubyte src[4], void *dst)
  144. {
  145.    GLuint *d = ((GLuint *) dst);
  146.    *d = PACK_COLOR_8888(src[ACOMP], src[BCOMP], src[GCOMP], src[RCOMP]);
  147. }
  148.  
  149. static void
  150. pack_float_RGBA8888_REV(const GLfloat src[4], void *dst)
  151. {
  152.    GLubyte v[4];
  153.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  154.    pack_ubyte_RGBA8888_REV(v, dst);
  155. }
  156.  
  157. static void
  158. pack_row_ubyte_RGBA8888_REV(GLuint n, const GLubyte src[][4], void *dst)
  159. {
  160.    GLuint *d = ((GLuint *) dst);
  161.    GLuint i;
  162.    for (i = 0; i < n; i++) {
  163.       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][BCOMP],
  164.                              src[i][GCOMP], src[i][RCOMP]);
  165.    }
  166. }
  167.  
  168. static void
  169. pack_row_float_RGBA8888_REV(GLuint n, const GLfloat src[][4], void *dst)
  170. {
  171.    GLuint *d = ((GLuint *) dst);
  172.    GLuint i;
  173.    for (i = 0; i < n; i++) {
  174.       GLubyte v[4];
  175.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  176.       pack_ubyte_RGBA8888_REV(v, d + i);
  177.    }
  178. }
  179.  
  180.  
  181. /*
  182.  * MESA_FORMAT_ARGB8888
  183.  */
  184.  
  185. static void
  186. pack_ubyte_ARGB8888(const GLubyte src[4], void *dst)
  187. {
  188.    GLuint *d = ((GLuint *) dst);
  189.    *d = PACK_COLOR_8888(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
  190. }
  191.  
  192. static void
  193. pack_float_ARGB8888(const GLfloat src[4], void *dst)
  194. {
  195.    GLubyte v[4];
  196.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  197.    pack_ubyte_ARGB8888(v, dst);
  198. }
  199.  
  200. static void
  201. pack_row_ubyte_ARGB8888(GLuint n, const GLubyte src[][4], void *dst)
  202. {
  203.    GLuint *d = ((GLuint *) dst);
  204.    GLuint i;
  205.    for (i = 0; i < n; i++) {
  206.       d[i] = PACK_COLOR_8888(src[i][ACOMP], src[i][RCOMP],
  207.                              src[i][GCOMP], src[i][BCOMP]);
  208.    }
  209. }
  210.  
  211. static void
  212. pack_row_float_ARGB8888(GLuint n, const GLfloat src[][4], void *dst)
  213. {
  214.    GLuint *d = ((GLuint *) dst);
  215.    GLuint i;
  216.    for (i = 0; i < n; i++) {
  217.       GLubyte v[4];
  218.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  219.       pack_ubyte_ARGB8888(v, d + i);
  220.    }
  221. }
  222.  
  223.  
  224. /*
  225.  * MESA_FORMAT_ARGB8888_REV
  226.  */
  227.  
  228. static void
  229. pack_ubyte_ARGB8888_REV(const GLubyte src[4], void *dst)
  230. {
  231.    GLuint *d = ((GLuint *) dst);
  232.    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], src[ACOMP]);
  233. }
  234.  
  235. static void
  236. pack_float_ARGB8888_REV(const GLfloat src[4], void *dst)
  237. {
  238.    GLubyte v[4];
  239.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  240.    pack_ubyte_ARGB8888_REV(v, dst);
  241. }
  242.  
  243. static void
  244. pack_row_ubyte_ARGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
  245. {
  246.    GLuint *d = ((GLuint *) dst);
  247.    GLuint i;
  248.    for (i = 0; i < n; i++) {
  249.       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP],
  250.                              src[i][RCOMP], src[i][ACOMP]);
  251.    }
  252. }
  253.  
  254. static void
  255. pack_row_float_ARGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
  256. {
  257.    GLuint *d = ((GLuint *) dst);
  258.    GLuint i;
  259.    for (i = 0; i < n; i++) {
  260.       GLubyte v[4];
  261.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  262.       pack_ubyte_ARGB8888_REV(v, d + i);
  263.    }
  264. }
  265.  
  266.  
  267. /*
  268.  * MESA_FORMAT_XRGB8888
  269.  */
  270.  
  271. static void
  272. pack_ubyte_XRGB8888(const GLubyte src[4], void *dst)
  273. {
  274.    GLuint *d = ((GLuint *) dst);
  275.    *d = PACK_COLOR_8888(0x0, src[RCOMP], src[GCOMP], src[BCOMP]);
  276. }
  277.  
  278. static void
  279. pack_float_XRGB8888(const GLfloat src[4], void *dst)
  280. {
  281.    GLubyte v[4];
  282.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  283.    pack_ubyte_XRGB8888(v, dst);
  284. }
  285.  
  286. static void
  287. pack_row_ubyte_XRGB8888(GLuint n, const GLubyte src[][4], void *dst)
  288. {
  289.    GLuint *d = ((GLuint *) dst);
  290.    GLuint i;
  291.    for (i = 0; i < n; i++) {
  292.       d[i] = PACK_COLOR_8888(0, src[i][RCOMP], src[i][GCOMP], src[i][BCOMP]);
  293.    }
  294. }
  295.  
  296. static void
  297. pack_row_float_XRGB8888(GLuint n, const GLfloat src[][4], void *dst)
  298. {
  299.    GLuint *d = ((GLuint *) dst);
  300.    GLuint i;
  301.    for (i = 0; i < n; i++) {
  302.       GLubyte v[4];
  303.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  304.       pack_ubyte_XRGB8888(v, d + i);
  305.    }
  306. }
  307.  
  308.  
  309. /*
  310.  * MESA_FORMAT_XRGB8888_REV
  311.  */
  312.  
  313. static void
  314. pack_ubyte_XRGB8888_REV(const GLubyte src[4], void *dst)
  315. {
  316.    GLuint *d = ((GLuint *) dst);
  317.    *d = PACK_COLOR_8888(src[BCOMP], src[GCOMP], src[RCOMP], 0);
  318. }
  319.  
  320. static void
  321. pack_float_XRGB8888_REV(const GLfloat src[4], void *dst)
  322. {
  323.    GLubyte v[4];
  324.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  325.    pack_ubyte_XRGB8888_REV(v, dst);
  326. }
  327.  
  328. static void
  329. pack_row_ubyte_XRGB8888_REV(GLuint n, const GLubyte src[][4], void *dst)
  330. {
  331.    GLuint *d = ((GLuint *) dst);
  332.    GLuint i;
  333.    for (i = 0; i < n; i++) {
  334.       d[i] = PACK_COLOR_8888(src[i][BCOMP], src[i][GCOMP], src[i][RCOMP], 0);
  335.    }
  336. }
  337.  
  338. static void
  339. pack_row_float_XRGB8888_REV(GLuint n, const GLfloat src[][4], void *dst)
  340. {
  341.    GLuint *d = ((GLuint *) dst);
  342.    GLuint i;
  343.    for (i = 0; i < n; i++) {
  344.       GLubyte v[4];
  345.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  346.       pack_ubyte_XRGB8888_REV(v, d + i);
  347.    }
  348. }
  349.  
  350.  
  351. /*
  352.  * MESA_FORMAT_RGB888
  353.  */
  354.  
  355. static void
  356. pack_ubyte_RGB888(const GLubyte src[4], void *dst)
  357. {
  358.    GLubyte *d = ((GLubyte *) dst);
  359.    d[2] = src[RCOMP];
  360.    d[1] = src[GCOMP];
  361.    d[0] = src[BCOMP];
  362. }
  363.  
  364. static void
  365. pack_float_RGB888(const GLfloat src[4], void *dst)
  366. {
  367.    GLubyte *d = ((GLubyte *) dst);
  368.    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[RCOMP]);
  369.    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
  370.    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[BCOMP]);
  371. }
  372.  
  373. static void
  374. pack_row_ubyte_RGB888(GLuint n, const GLubyte src[][4], void *dst)
  375. {
  376.    GLubyte *d = ((GLubyte *) dst);
  377.    GLuint i;
  378.    for (i = 0; i < n; i++) {
  379.       d[i*3+2] = src[i][RCOMP];
  380.       d[i*3+1] = src[i][GCOMP];
  381.       d[i*3+0] = src[i][BCOMP];
  382.    }
  383. }
  384.  
  385. static void
  386. pack_row_float_RGB888(GLuint n, const GLfloat src[][4], void *dst)
  387. {
  388.    GLubyte *d = ((GLubyte *) dst);
  389.    GLuint i;
  390.    for (i = 0; i < n; i++) {
  391.       GLubyte v[4];
  392.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  393.       d[i*3+2] = v[RCOMP];
  394.       d[i*3+1] = v[GCOMP];
  395.       d[i*3+0] = v[BCOMP];
  396.    }
  397. }
  398.  
  399.  
  400. /*
  401.  * MESA_FORMAT_BGR888
  402.  */
  403.  
  404. static void
  405. pack_ubyte_BGR888(const GLubyte src[4], void *dst)
  406. {
  407.    GLubyte *d = ((GLubyte *) dst);
  408.    d[2] = src[BCOMP];
  409.    d[1] = src[GCOMP];
  410.    d[0] = src[RCOMP];
  411. }
  412.  
  413. static void
  414. pack_float_BGR888(const GLfloat src[4], void *dst)
  415. {
  416.    GLubyte *d = ((GLubyte *) dst);
  417.    UNCLAMPED_FLOAT_TO_UBYTE(d[2], src[BCOMP]);
  418.    UNCLAMPED_FLOAT_TO_UBYTE(d[1], src[GCOMP]);
  419.    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
  420. }
  421.  
  422. static void
  423. pack_row_ubyte_BGR888(GLuint n, const GLubyte src[][4], void *dst)
  424. {
  425.    GLubyte *d = ((GLubyte *) dst);
  426.    GLuint i;
  427.    for (i = 0; i < n; i++) {
  428.       d[i*3+2] = src[i][BCOMP];
  429.       d[i*3+1] = src[i][GCOMP];
  430.       d[i*3+0] = src[i][RCOMP];
  431.    }
  432. }
  433.  
  434. static void
  435. pack_row_float_BGR888(GLuint n, const GLfloat src[][4], void *dst)
  436. {
  437.    GLubyte *d = ((GLubyte *) dst);
  438.    GLuint i;
  439.    for (i = 0; i < n; i++) {
  440.       GLubyte v[4];
  441.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  442.       d[i*3+2] = v[BCOMP];
  443.       d[i*3+1] = v[GCOMP];
  444.       d[i*3+0] = v[RCOMP];
  445.    }
  446. }
  447.  
  448.  
  449. /*
  450.  * MESA_FORMAT_RGB565
  451.  */
  452.  
  453. static void
  454. pack_ubyte_RGB565(const GLubyte src[4], void *dst)
  455. {
  456.    GLushort *d = ((GLushort *) dst);
  457.    *d = PACK_COLOR_565(src[RCOMP], src[GCOMP], src[BCOMP]);
  458. }
  459.  
  460. static void
  461. pack_float_RGB565(const GLfloat src[4], void *dst)
  462. {
  463.    GLubyte v[3];
  464.    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
  465.    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
  466.    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
  467.    pack_ubyte_RGB565(v, dst);
  468. }
  469.  
  470. static void
  471. pack_row_ubyte_RGB565(GLuint n, const GLubyte src[][4], void *dst)
  472. {
  473.    GLushort *d = ((GLushort *) dst);
  474.    GLuint i;
  475.    for (i = 0; i < n; i++) {
  476.       pack_ubyte_RGB565(src[i], d + i);
  477.    }
  478. }
  479.  
  480. static void
  481. pack_row_float_RGB565(GLuint n, const GLfloat src[][4], void *dst)
  482. {
  483.    GLushort *d = ((GLushort *) dst);
  484.    GLuint i;
  485.    for (i = 0; i < n; i++) {
  486.       GLubyte v[4];
  487.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  488.       pack_ubyte_RGB565(v, d + i);
  489.    }
  490. }
  491.  
  492.  
  493. /*
  494.  * MESA_FORMAT_RGB565_REV
  495.  */
  496.  
  497. static void
  498. pack_ubyte_RGB565_REV(const GLubyte src[4], void *dst)
  499. {
  500.    GLushort *d = ((GLushort *) dst);
  501.    *d = PACK_COLOR_565_REV(src[RCOMP], src[GCOMP], src[BCOMP]);
  502. }
  503.  
  504. static void
  505. pack_float_RGB565_REV(const GLfloat src[4], void *dst)
  506. {
  507.    GLushort *d = ((GLushort *) dst);
  508.    GLubyte r, g, b;
  509.    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
  510.    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
  511.    UNCLAMPED_FLOAT_TO_UBYTE(b, src[BCOMP]);
  512.    *d = PACK_COLOR_565_REV(r, g, b);
  513. }
  514.  
  515. static void
  516. pack_row_ubyte_RGB565_REV(GLuint n, const GLubyte src[][4], void *dst)
  517. {
  518.    GLushort *d = ((GLushort *) dst);
  519.    GLuint i;
  520.    for (i = 0; i < n; i++) {
  521.       pack_ubyte_RGB565_REV(src[i], d + i);
  522.    }
  523. }
  524.  
  525. static void
  526. pack_row_float_RGB565_REV(GLuint n, const GLfloat src[][4], void *dst)
  527. {
  528.    GLushort *d = ((GLushort *) dst);
  529.    GLuint i;
  530.    for (i = 0; i < n; i++) {
  531.       GLubyte v[4];
  532.       _mesa_unclamped_float_rgba_to_ubyte(v, src[i]);
  533.       pack_ubyte_RGB565_REV(v, d + i);
  534.    }
  535. }
  536.  
  537.  
  538. /*
  539.  * MESA_FORMAT_ARGB4444
  540.  */
  541.  
  542. static void
  543. pack_ubyte_ARGB4444(const GLubyte src[4], void *dst)
  544. {
  545.    GLushort *d = ((GLushort *) dst);
  546.    *d = PACK_COLOR_4444(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
  547. }
  548.  
  549. static void
  550. pack_float_ARGB4444(const GLfloat src[4], void *dst)
  551. {
  552.    GLubyte v[4];
  553.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  554.    pack_ubyte_ARGB4444(v, dst);
  555. }
  556.  
  557. /* use fallback row packing functions */
  558.  
  559.  
  560. /*
  561.  * MESA_FORMAT_ARGB4444_REV
  562.  */
  563.  
  564. static void
  565. pack_ubyte_ARGB4444_REV(const GLubyte src[4], void *dst)
  566. {
  567.    GLushort *d = ((GLushort *) dst);
  568.    *d = PACK_COLOR_4444(src[GCOMP], src[BCOMP], src[ACOMP], src[RCOMP]);
  569. }
  570.  
  571. static void
  572. pack_float_ARGB4444_REV(const GLfloat src[4], void *dst)
  573. {
  574.    GLubyte v[4];
  575.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  576.    pack_ubyte_ARGB4444_REV(v, dst);
  577. }
  578.  
  579. /* use fallback row packing functions */
  580.  
  581.  
  582. /*
  583.  * MESA_FORMAT_RGBA5551
  584.  */
  585.  
  586. static void
  587. pack_ubyte_RGBA5551(const GLubyte src[4], void *dst)
  588. {
  589.    GLushort *d = ((GLushort *) dst);
  590.    *d = PACK_COLOR_5551(src[RCOMP], src[GCOMP], src[BCOMP], src[ACOMP]);
  591. }
  592.  
  593. static void
  594. pack_float_RGBA5551(const GLfloat src[4], void *dst)
  595. {
  596.    GLubyte v[4];
  597.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  598.    pack_ubyte_RGBA5551(v, dst);
  599. }
  600.  
  601. /* use fallback row packing functions */
  602.  
  603.  
  604. /*
  605.  * MESA_FORMAT_ARGB1555
  606.  */
  607.  
  608. static void
  609. pack_ubyte_ARGB1555(const GLubyte src[4], void *dst)
  610. {
  611.    GLushort *d = ((GLushort *) dst);
  612.    *d = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
  613. }
  614.  
  615. static void
  616. pack_float_ARGB1555(const GLfloat src[4], void *dst)
  617. {
  618.    GLubyte v[4];
  619.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  620.    pack_ubyte_ARGB1555(v, dst);
  621. }
  622.  
  623.  
  624. /* MESA_FORMAT_ARGB1555_REV */
  625.  
  626. static void
  627. pack_ubyte_ARGB1555_REV(const GLubyte src[4], void *dst)
  628. {
  629.    GLushort *d = ((GLushort *) dst), tmp;
  630.    tmp = PACK_COLOR_1555(src[ACOMP], src[RCOMP], src[GCOMP], src[BCOMP]);
  631.    *d = (tmp >> 8) | (tmp << 8);
  632. }
  633.  
  634. static void
  635. pack_float_ARGB1555_REV(const GLfloat src[4], void *dst)
  636. {
  637.    GLubyte v[4];
  638.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  639.    pack_ubyte_ARGB1555_REV(v, dst);
  640. }
  641.  
  642.  
  643. /* MESA_FORMAT_AL44 */
  644.  
  645. static void
  646. pack_ubyte_AL44(const GLubyte src[4], void *dst)
  647. {
  648.    GLubyte *d = ((GLubyte *) dst);
  649.    *d = PACK_COLOR_44(src[ACOMP], src[RCOMP]);
  650. }
  651.  
  652. static void
  653. pack_float_AL44(const GLfloat src[4], void *dst)
  654. {
  655.    GLubyte v[4];
  656.    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
  657.    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
  658.    pack_ubyte_AL44(v, dst);
  659. }
  660.  
  661.  
  662. /* MESA_FORMAT_AL88 */
  663.  
  664. static void
  665. pack_ubyte_AL88(const GLubyte src[4], void *dst)
  666. {
  667.    GLushort *d = ((GLushort *) dst);
  668.    *d = PACK_COLOR_88(src[ACOMP], src[RCOMP]);
  669. }
  670.  
  671. static void
  672. pack_float_AL88(const GLfloat src[4], void *dst)
  673. {
  674.    GLubyte v[4];
  675.    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
  676.    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
  677.    pack_ubyte_AL88(v, dst);
  678. }
  679.  
  680.  
  681. /* MESA_FORMAT_AL88_REV */
  682.  
  683. static void
  684. pack_ubyte_AL88_REV(const GLubyte src[4], void *dst)
  685. {
  686.    GLushort *d = ((GLushort *) dst);
  687.    *d = PACK_COLOR_88(src[RCOMP], src[ACOMP]);
  688. }
  689.  
  690. static void
  691. pack_float_AL88_REV(const GLfloat src[4], void *dst)
  692. {
  693.    GLubyte v[4];
  694.    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
  695.    UNCLAMPED_FLOAT_TO_UBYTE(v[3], src[ACOMP]);
  696.    pack_ubyte_AL88_REV(v, dst);
  697. }
  698.  
  699.  
  700. /* MESA_FORMAT_AL1616 */
  701.  
  702. static void
  703. pack_ubyte_AL1616(const GLubyte src[4], void *dst)
  704. {
  705.    GLuint *d = ((GLuint *) dst);
  706.    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
  707.    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
  708.    *d = PACK_COLOR_1616(a, l);
  709. }
  710.  
  711. static void
  712. pack_float_AL1616(const GLfloat src[4], void *dst)
  713. {
  714.    GLuint *d = ((GLuint *) dst);
  715.    GLushort l, a;
  716.    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
  717.    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
  718.    *d = PACK_COLOR_1616(a, l);
  719. }
  720.  
  721.  
  722. /* MESA_FORMAT_AL1616_REV */
  723.  
  724. static void
  725. pack_ubyte_AL1616_REV(const GLubyte src[4], void *dst)
  726. {
  727.    GLuint *d = ((GLuint *) dst);
  728.    GLushort l = UBYTE_TO_USHORT(src[RCOMP]);
  729.    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
  730.    *d = PACK_COLOR_1616(l, a);
  731. }
  732.  
  733. static void
  734. pack_float_AL1616_REV(const GLfloat src[4], void *dst)
  735. {
  736.    GLuint *d = ((GLuint *) dst);
  737.    GLushort l, a;
  738.    UNCLAMPED_FLOAT_TO_USHORT(l, src[RCOMP]);
  739.    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
  740.    *d = PACK_COLOR_1616(l, a);
  741. }
  742.  
  743.  
  744. /* MESA_FORMAT_RGB332 */
  745.  
  746. static void
  747. pack_ubyte_RGB332(const GLubyte src[4], void *dst)
  748. {
  749.    GLubyte *d = ((GLubyte *) dst);
  750.    *d = PACK_COLOR_332(src[RCOMP], src[GCOMP], src[BCOMP]);
  751. }
  752.  
  753. static void
  754. pack_float_RGB332(const GLfloat src[4], void *dst)
  755. {
  756.    GLubyte v[4];
  757.    UNCLAMPED_FLOAT_TO_UBYTE(v[0], src[RCOMP]);
  758.    UNCLAMPED_FLOAT_TO_UBYTE(v[1], src[GCOMP]);
  759.    UNCLAMPED_FLOAT_TO_UBYTE(v[2], src[BCOMP]);
  760.    pack_ubyte_RGB332(v, dst);
  761. }
  762.  
  763.  
  764. /* MESA_FORMAT_A8 */
  765.  
  766. static void
  767. pack_ubyte_A8(const GLubyte src[4], void *dst)
  768. {
  769.    GLubyte *d = ((GLubyte *) dst);
  770.    *d = src[ACOMP];
  771. }
  772.  
  773. static void
  774. pack_float_A8(const GLfloat src[4], void *dst)
  775. {
  776.    GLubyte *d = ((GLubyte *) dst);
  777.    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[ACOMP]);
  778. }
  779.  
  780.  
  781. /* MESA_FORMAT_A16 */
  782.  
  783. static void
  784. pack_ubyte_A16(const GLubyte src[4], void *dst)
  785. {
  786.    GLushort *d = ((GLushort *) dst);
  787.    *d = UBYTE_TO_USHORT(src[ACOMP]);
  788. }
  789.  
  790. static void
  791. pack_float_A16(const GLfloat src[4], void *dst)
  792. {
  793.    GLushort *d = ((GLushort *) dst);
  794.    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[ACOMP]);
  795. }
  796.  
  797.  
  798. /* MESA_FORMAT_L8 */
  799.  
  800. static void
  801. pack_ubyte_L8(const GLubyte src[4], void *dst)
  802. {
  803.    GLubyte *d = ((GLubyte *) dst);
  804.    *d = src[RCOMP];
  805. }
  806.  
  807. static void
  808. pack_float_L8(const GLfloat src[4], void *dst)
  809. {
  810.    GLubyte *d = ((GLubyte *) dst);
  811.    UNCLAMPED_FLOAT_TO_UBYTE(d[0], src[RCOMP]);
  812. }
  813.  
  814.  
  815. /* MESA_FORMAT_L16 */
  816.  
  817. static void
  818. pack_ubyte_L16(const GLubyte src[4], void *dst)
  819. {
  820.    GLushort *d = ((GLushort *) dst);
  821.    *d = UBYTE_TO_USHORT(src[RCOMP]);
  822. }
  823.  
  824. static void
  825. pack_float_L16(const GLfloat src[4], void *dst)
  826. {
  827.    GLushort *d = ((GLushort *) dst);
  828.    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
  829. }
  830.  
  831.  
  832. /* MESA_FORMAT_YCBCR */
  833.  
  834. static void
  835. pack_ubyte_YCBCR(const GLubyte src[4], void *dst)
  836. {
  837.    /* todo */
  838. }
  839.  
  840. static void
  841. pack_float_YCBCR(const GLfloat src[4], void *dst)
  842. {
  843.    /* todo */
  844. }
  845.  
  846.  
  847. /* MESA_FORMAT_YCBCR_REV */
  848.  
  849. static void
  850. pack_ubyte_YCBCR_REV(const GLubyte src[4], void *dst)
  851. {
  852.    /* todo */
  853. }
  854.  
  855. static void
  856. pack_float_YCBCR_REV(const GLfloat src[4], void *dst)
  857. {
  858.    /* todo */
  859. }
  860.  
  861.  
  862. /* MESA_FORMAT_R8 */
  863.  
  864. static void
  865. pack_ubyte_R8(const GLubyte src[4], void *dst)
  866. {
  867.    GLubyte *d = ((GLubyte *) dst);
  868.    *d = src[RCOMP];
  869. }
  870.  
  871. static void
  872. pack_float_R8(const GLfloat src[4], void *dst)
  873. {
  874.    GLubyte *d = ((GLubyte *) dst);
  875.    GLubyte r;
  876.    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
  877.    d[0] = r;
  878. }
  879.  
  880.  
  881. /* MESA_FORMAT_GR88 */
  882.  
  883. static void
  884. pack_ubyte_GR88(const GLubyte src[4], void *dst)
  885. {
  886.    GLubyte *d = ((GLubyte *) dst);
  887.    *d = PACK_COLOR_88(src[GCOMP], src[RCOMP]);
  888. }
  889.  
  890. static void
  891. pack_float_GR88(const GLfloat src[4], void *dst)
  892. {
  893.    GLushort *d = ((GLushort *) dst);
  894.    GLubyte r, g;
  895.    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
  896.    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
  897.    *d = PACK_COLOR_88(g, r);
  898. }
  899.  
  900.  
  901. /* MESA_FORMAT_RG88 */
  902.  
  903. static void
  904. pack_ubyte_RG88(const GLubyte src[4], void *dst)
  905. {
  906.    GLubyte *d = ((GLubyte *) dst);
  907.    *d = PACK_COLOR_88(src[RCOMP], src[GCOMP]);
  908. }
  909.  
  910. static void
  911. pack_float_RG88(const GLfloat src[4], void *dst)
  912. {
  913.    GLushort *d = ((GLushort *) dst);
  914.    GLubyte r, g;
  915.    UNCLAMPED_FLOAT_TO_UBYTE(r, src[RCOMP]);
  916.    UNCLAMPED_FLOAT_TO_UBYTE(g, src[GCOMP]);
  917.    *d = PACK_COLOR_88(r, g);
  918. }
  919.  
  920.  
  921. /* MESA_FORMAT_R16 */
  922.  
  923. static void
  924. pack_ubyte_R16(const GLubyte src[4], void *dst)
  925. {
  926.    GLushort *d = ((GLushort *) dst);
  927.    *d = UBYTE_TO_USHORT(src[RCOMP]);
  928. }
  929.  
  930. static void
  931. pack_float_R16(const GLfloat src[4], void *dst)
  932. {
  933.    GLushort *d = ((GLushort *) dst);
  934.    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
  935. }
  936.  
  937.  
  938. /* MESA_FORMAT_GR1616 */
  939.  
  940. static void
  941. pack_ubyte_GR1616(const GLubyte src[4], void *dst)
  942. {
  943.    GLuint *d = ((GLuint *) dst);
  944.    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
  945.    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
  946.    *d = PACK_COLOR_1616(g, r);
  947. }
  948.  
  949. static void
  950. pack_float_GR1616(const GLfloat src[4], void *dst)
  951. {
  952.    GLuint *d = ((GLuint *) dst);
  953.    GLushort r, g;
  954.    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
  955.    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
  956.    *d = PACK_COLOR_1616(g, r);
  957. }
  958.  
  959.  
  960. /* MESA_FORMAT_RG1616 */
  961.  
  962. static void
  963. pack_ubyte_RG1616(const GLubyte src[4], void *dst)
  964. {
  965.    GLuint *d = ((GLuint *) dst);
  966.    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
  967.    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
  968.    *d = PACK_COLOR_1616(r, g);
  969. }
  970.  
  971.  
  972. static void
  973. pack_float_RG1616(const GLfloat src[4], void *dst)
  974. {
  975.    GLuint *d = ((GLuint *) dst);
  976.    GLushort r, g;
  977.    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
  978.    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
  979.    *d = PACK_COLOR_1616(r, g);
  980. }
  981.  
  982.  
  983. /* MESA_FORMAT_ARGB2101010 */
  984.  
  985. static void
  986. pack_ubyte_ARGB2101010(const GLubyte src[4], void *dst)
  987. {
  988.    GLuint *d = ((GLuint *) dst);
  989.    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
  990.    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
  991.    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
  992.    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
  993.    *d = PACK_COLOR_2101010_US(a, r, g, b);
  994. }
  995.  
  996. static void
  997. pack_float_ARGB2101010(const GLfloat src[4], void *dst)
  998. {
  999.    GLuint *d = ((GLuint *) dst);
  1000.    GLushort r, g, b, a;
  1001.    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
  1002.    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
  1003.    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
  1004.    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
  1005.    *d = PACK_COLOR_2101010_US(a, r, g, b);
  1006. }
  1007.  
  1008.  
  1009. /* MESA_FORMAT_ABGR2101010_UINT */
  1010.  
  1011. static void
  1012. pack_ubyte_ABGR2101010_UINT(const GLubyte src[4], void *dst)
  1013. {
  1014.    GLuint *d = ((GLuint *) dst);
  1015.    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
  1016.    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
  1017.    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
  1018.    GLushort a = UBYTE_TO_USHORT(src[ACOMP]);
  1019.    *d = PACK_COLOR_2101010_US(a, b, g, r);
  1020. }
  1021.  
  1022. static void
  1023. pack_float_ABGR2101010_UINT(const GLfloat src[4], void *dst)
  1024. {
  1025.    GLuint *d = ((GLuint *) dst);
  1026.    GLushort r, g, b, a;
  1027.    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
  1028.    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
  1029.    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
  1030.    UNCLAMPED_FLOAT_TO_USHORT(a, src[ACOMP]);
  1031.    *d = PACK_COLOR_2101010_US(a, b, g, r);
  1032. }
  1033.  
  1034.  
  1035. /* MESA_FORMAT_SRGB8 */
  1036.  
  1037. static void
  1038. pack_ubyte_SRGB8(const GLubyte src[4], void *dst)
  1039. {
  1040.    GLubyte *d = ((GLubyte *) dst);
  1041.    d[2] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1042.    d[1] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1043.    d[0] = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1044. }
  1045.  
  1046. static void
  1047. pack_float_SRGB8(const GLfloat src[4], void *dst)
  1048. {
  1049.    GLubyte *d = ((GLubyte *) dst);
  1050.    d[2] = linear_float_to_srgb_ubyte(src[RCOMP]);
  1051.    d[1] = linear_float_to_srgb_ubyte(src[GCOMP]);
  1052.    d[0] = linear_float_to_srgb_ubyte(src[BCOMP]);
  1053. }
  1054.  
  1055.  
  1056. /* MESA_FORMAT_SRGBA8 */
  1057.  
  1058. static void
  1059. pack_ubyte_SRGBA8(const GLubyte src[4], void *dst)
  1060. {
  1061.    GLuint *d = ((GLuint *) dst);
  1062.    GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1063.    GLubyte g = linear_ubyte_to_srgb_ubyte(src[GCOMP]);
  1064.    GLubyte b = linear_ubyte_to_srgb_ubyte(src[BCOMP]);
  1065.    *d = PACK_COLOR_8888(r, g, b, src[ACOMP]);
  1066. }
  1067.  
  1068. static void
  1069. pack_float_SRGBA8(const GLfloat src[4], void *dst)
  1070. {
  1071.    GLuint *d = ((GLuint *) dst);
  1072.    GLubyte r, g, b, a;
  1073.    r = linear_float_to_srgb_ubyte(src[RCOMP]);
  1074.    g = linear_float_to_srgb_ubyte(src[GCOMP]);
  1075.    b = linear_float_to_srgb_ubyte(src[BCOMP]);
  1076.    UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
  1077.    *d = PACK_COLOR_8888(r, g, b, a);
  1078. }
  1079.  
  1080.  
  1081. /* MESA_FORMAT_SARGB8 */
  1082.  
  1083. static void
  1084. pack_ubyte_SARGB8(const GLubyte src[4], void *dst)
  1085. {
  1086.    GLuint *d = ((GLuint *) dst);
  1087.    GLubyte r = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1088.    GLubyte g = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1089.    GLubyte b = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1090.    *d = PACK_COLOR_8888(src[ACOMP], r, g, b);
  1091. }
  1092.  
  1093. static void
  1094. pack_float_SARGB8(const GLfloat src[4], void *dst)
  1095. {
  1096.    GLuint *d = ((GLuint *) dst);
  1097.    GLubyte r, g, b, a;
  1098.    r = linear_float_to_srgb_ubyte(src[RCOMP]);
  1099.    g = linear_float_to_srgb_ubyte(src[GCOMP]);
  1100.    b = linear_float_to_srgb_ubyte(src[BCOMP]);
  1101.    UNCLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
  1102.    *d = PACK_COLOR_8888(a, r, g, b);
  1103. }
  1104.  
  1105.  
  1106. /* MESA_FORMAT_SL8 */
  1107.  
  1108. static void
  1109. pack_ubyte_SL8(const GLubyte src[4], void *dst)
  1110. {
  1111.    GLubyte *d = ((GLubyte *) dst);
  1112.    *d = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1113. }
  1114.  
  1115. static void
  1116. pack_float_SL8(const GLfloat src[4], void *dst)
  1117. {
  1118.    GLubyte *d = ((GLubyte *) dst);
  1119.    GLubyte l = linear_float_to_srgb_ubyte(src[RCOMP]);
  1120.    *d = l;
  1121. }
  1122.  
  1123.  
  1124. /* MESA_FORMAT_SLA8 */
  1125.  
  1126. static void
  1127. pack_ubyte_SLA8(const GLubyte src[4], void *dst)
  1128. {
  1129.    GLushort *d = ((GLushort *) dst);
  1130.    GLubyte l = linear_ubyte_to_srgb_ubyte(src[RCOMP]);
  1131.    *d = PACK_COLOR_88(src[ACOMP], l);
  1132. }
  1133.  
  1134. static void
  1135. pack_float_SLA8(const GLfloat src[4], void *dst)
  1136. {
  1137.    GLushort *d = ((GLushort *) dst);
  1138.    GLubyte a, l = linear_float_to_srgb_ubyte(src[RCOMP]);
  1139.    CLAMPED_FLOAT_TO_UBYTE(a, src[ACOMP]);
  1140.    *d = PACK_COLOR_88(a, l);
  1141. }
  1142.  
  1143.  
  1144. /* MESA_FORMAT_RGBA_FLOAT32 */
  1145.  
  1146. static void
  1147. pack_ubyte_RGBA_FLOAT32(const GLubyte src[4], void *dst)
  1148. {
  1149.    GLfloat *d = ((GLfloat *) dst);
  1150.    d[0] = UBYTE_TO_FLOAT(src[0]);
  1151.    d[1] = UBYTE_TO_FLOAT(src[1]);
  1152.    d[2] = UBYTE_TO_FLOAT(src[2]);
  1153.    d[3] = UBYTE_TO_FLOAT(src[3]);
  1154. }
  1155.  
  1156. static void
  1157. pack_float_RGBA_FLOAT32(const GLfloat src[4], void *dst)
  1158. {
  1159.    GLfloat *d = ((GLfloat *) dst);
  1160.    d[0] = src[0];
  1161.    d[1] = src[1];
  1162.    d[2] = src[2];
  1163.    d[3] = src[3];
  1164. }
  1165.  
  1166.  
  1167. /* MESA_FORMAT_RGBA_FLOAT16 */
  1168.  
  1169. static void
  1170. pack_ubyte_RGBA_FLOAT16(const GLubyte src[4], void *dst)
  1171. {
  1172.    GLhalfARB *d = ((GLhalfARB *) dst);
  1173.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
  1174.    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
  1175.    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
  1176.    d[3] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[3]));
  1177. }
  1178.  
  1179. static void
  1180. pack_float_RGBA_FLOAT16(const GLfloat src[4], void *dst)
  1181. {
  1182.    GLhalfARB *d = ((GLhalfARB *) dst);
  1183.    d[0] = _mesa_float_to_half(src[0]);
  1184.    d[1] = _mesa_float_to_half(src[1]);
  1185.    d[2] = _mesa_float_to_half(src[2]);
  1186.    d[3] = _mesa_float_to_half(src[3]);
  1187. }
  1188.  
  1189.  
  1190. /* MESA_FORMAT_RGB_FLOAT32 */
  1191.  
  1192. static void
  1193. pack_ubyte_RGB_FLOAT32(const GLubyte src[4], void *dst)
  1194. {
  1195.    GLfloat *d = ((GLfloat *) dst);
  1196.    d[0] = UBYTE_TO_FLOAT(src[0]);
  1197.    d[1] = UBYTE_TO_FLOAT(src[1]);
  1198.    d[2] = UBYTE_TO_FLOAT(src[2]);
  1199. }
  1200.  
  1201. static void
  1202. pack_float_RGB_FLOAT32(const GLfloat src[4], void *dst)
  1203. {
  1204.    GLfloat *d = ((GLfloat *) dst);
  1205.    d[0] = src[0];
  1206.    d[1] = src[1];
  1207.    d[2] = src[2];
  1208. }
  1209.  
  1210.  
  1211. /* MESA_FORMAT_RGB_FLOAT16 */
  1212.  
  1213. static void
  1214. pack_ubyte_RGB_FLOAT16(const GLubyte src[4], void *dst)
  1215. {
  1216.    GLhalfARB *d = ((GLhalfARB *) dst);
  1217.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[0]));
  1218.    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[1]));
  1219.    d[2] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[2]));
  1220. }
  1221.  
  1222. static void
  1223. pack_float_RGB_FLOAT16(const GLfloat src[4], void *dst)
  1224. {
  1225.    GLhalfARB *d = ((GLhalfARB *) dst);
  1226.    d[0] = _mesa_float_to_half(src[0]);
  1227.    d[1] = _mesa_float_to_half(src[1]);
  1228.    d[2] = _mesa_float_to_half(src[2]);
  1229. }
  1230.  
  1231.  
  1232. /* MESA_FORMAT_ALPHA_FLOAT32 */
  1233.  
  1234. static void
  1235. pack_ubyte_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
  1236. {
  1237.    GLfloat *d = ((GLfloat *) dst);
  1238.    d[0] = UBYTE_TO_FLOAT(src[ACOMP]);
  1239. }
  1240.  
  1241. static void
  1242. pack_float_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
  1243. {
  1244.    GLfloat *d = ((GLfloat *) dst);
  1245.    d[0] = src[ACOMP];
  1246. }
  1247.  
  1248.  
  1249. /* MESA_FORMAT_ALPHA_FLOAT16 */
  1250.  
  1251. static void
  1252. pack_ubyte_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
  1253. {
  1254.    GLhalfARB *d = ((GLhalfARB *) dst);
  1255.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
  1256. }
  1257.  
  1258. static void
  1259. pack_float_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
  1260. {
  1261.    GLhalfARB *d = ((GLhalfARB *) dst);
  1262.    d[0] = _mesa_float_to_half(src[ACOMP]);
  1263. }
  1264.  
  1265.  
  1266. /* MESA_FORMAT_LUMINANCE_FLOAT32 (and INTENSITY_FLOAT32, R_FLOAT32) */
  1267.  
  1268. static void
  1269. pack_ubyte_LUMINANCE_FLOAT32(const GLubyte src[4], void *dst)
  1270. {
  1271.    GLfloat *d = ((GLfloat *) dst);
  1272.    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
  1273. }
  1274.  
  1275. static void
  1276. pack_float_LUMINANCE_FLOAT32(const GLfloat src[4], void *dst)
  1277. {
  1278.    GLfloat *d = ((GLfloat *) dst);
  1279.    d[0] = src[RCOMP];
  1280. }
  1281.  
  1282.  
  1283. /* MESA_FORMAT_LUMINANCE_FLOAT16 (and INTENSITY_FLOAT16, R_FLOAT32) */
  1284.  
  1285. static void
  1286. pack_ubyte_LUMINANCE_FLOAT16(const GLubyte src[4], void *dst)
  1287. {
  1288.    GLhalfARB *d = ((GLhalfARB *) dst);
  1289.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
  1290. }
  1291.  
  1292. static void
  1293. pack_float_LUMINANCE_FLOAT16(const GLfloat src[4], void *dst)
  1294. {
  1295.    GLhalfARB *d = ((GLhalfARB *) dst);
  1296.    d[0] = _mesa_float_to_half(src[RCOMP]);
  1297. }
  1298.  
  1299.  
  1300. /* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32 */
  1301.  
  1302. static void
  1303. pack_ubyte_LUMINANCE_ALPHA_FLOAT32(const GLubyte src[4], void *dst)
  1304. {
  1305.    GLfloat *d = ((GLfloat *) dst);
  1306.    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
  1307.    d[1] = UBYTE_TO_FLOAT(src[ACOMP]);
  1308. }
  1309.  
  1310. static void
  1311. pack_float_LUMINANCE_ALPHA_FLOAT32(const GLfloat src[4], void *dst)
  1312. {
  1313.    GLfloat *d = ((GLfloat *) dst);
  1314.    d[0] = src[RCOMP];
  1315.    d[1] = src[ACOMP];
  1316. }
  1317.  
  1318.  
  1319. /* MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16 */
  1320.  
  1321. static void
  1322. pack_ubyte_LUMINANCE_ALPHA_FLOAT16(const GLubyte src[4], void *dst)
  1323. {
  1324.    GLhalfARB *d = ((GLhalfARB *) dst);
  1325.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
  1326.    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[ACOMP]));
  1327. }
  1328.  
  1329. static void
  1330. pack_float_LUMINANCE_ALPHA_FLOAT16(const GLfloat src[4], void *dst)
  1331. {
  1332.    GLhalfARB *d = ((GLhalfARB *) dst);
  1333.    d[0] = _mesa_float_to_half(src[RCOMP]);
  1334.    d[1] = _mesa_float_to_half(src[ACOMP]);
  1335. }
  1336.  
  1337.  
  1338. /* MESA_FORMAT_RG_FLOAT32 */
  1339.  
  1340. static void
  1341. pack_ubyte_RG_FLOAT32(const GLubyte src[4], void *dst)
  1342. {
  1343.    GLfloat *d = ((GLfloat *) dst);
  1344.    d[0] = UBYTE_TO_FLOAT(src[RCOMP]);
  1345.    d[1] = UBYTE_TO_FLOAT(src[GCOMP]);
  1346. }
  1347.  
  1348. static void
  1349. pack_float_RG_FLOAT32(const GLfloat src[4], void *dst)
  1350. {
  1351.    GLfloat *d = ((GLfloat *) dst);
  1352.    d[0] = src[RCOMP];
  1353.    d[1] = src[GCOMP];
  1354. }
  1355.  
  1356.  
  1357. /* MESA_FORMAT_RG_FLOAT16 */
  1358.  
  1359. static void
  1360. pack_ubyte_RG_FLOAT16(const GLubyte src[4], void *dst)
  1361. {
  1362.    GLhalfARB *d = ((GLhalfARB *) dst);
  1363.    d[0] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[RCOMP]));
  1364.    d[1] = _mesa_float_to_half(UBYTE_TO_FLOAT(src[GCOMP]));
  1365. }
  1366.  
  1367. static void
  1368. pack_float_RG_FLOAT16(const GLfloat src[4], void *dst)
  1369. {
  1370.    GLhalfARB *d = ((GLhalfARB *) dst);
  1371.    d[0] = _mesa_float_to_half(src[RCOMP]);
  1372.    d[1] = _mesa_float_to_half(src[GCOMP]);
  1373. }
  1374.  
  1375.  
  1376. /* MESA_FORMAT_DUDV8 */
  1377.  
  1378. static void
  1379. pack_ubyte_DUDV8(const GLubyte src[4], void *dst)
  1380. {
  1381.    /* XXX is this ever used? */
  1382.    GLushort *d = ((GLushort *) dst);
  1383.    *d = PACK_COLOR_88(src[0], src[1]);
  1384. }
  1385.  
  1386. static void
  1387. pack_float_DUDV8(const GLfloat src[4], void *dst)
  1388. {
  1389.    GLushort *d = ((GLushort *) dst);
  1390.    GLbyte du, dv;
  1391.    du = FLOAT_TO_BYTE(CLAMP(src[0], 0.0F, 1.0F));
  1392.    dv = FLOAT_TO_BYTE(CLAMP(src[1], 0.0F, 1.0F));
  1393.    *d = PACK_COLOR_88(du, dv);
  1394. }
  1395.  
  1396.  
  1397. /* MESA_FORMAT_RGBA_16 */
  1398.  
  1399. static void
  1400. pack_ubyte_RGBA_16(const GLubyte src[4], void *dst)
  1401. {
  1402.    GLushort *d = ((GLushort *) dst);
  1403.    d[0] = UBYTE_TO_USHORT(src[RCOMP]);
  1404.    d[1] = UBYTE_TO_USHORT(src[GCOMP]);
  1405.    d[2] = UBYTE_TO_USHORT(src[BCOMP]);
  1406.    d[3] = UBYTE_TO_USHORT(src[ACOMP]);
  1407. }
  1408.  
  1409. static void
  1410. pack_float_RGBA_16(const GLfloat src[4], void *dst)
  1411. {
  1412.    GLushort *d = ((GLushort *) dst);
  1413.    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
  1414.    UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
  1415.    UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
  1416.    UNCLAMPED_FLOAT_TO_USHORT(d[3], src[ACOMP]);
  1417. }
  1418.  
  1419.  
  1420.  
  1421. /*
  1422.  * MESA_FORMAT_SIGNED_R8
  1423.  */
  1424.  
  1425. static void
  1426. pack_float_SIGNED_R8(const GLfloat src[4], void *dst)
  1427. {
  1428.    GLbyte *d = (GLbyte *) dst;
  1429.    *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1430. }
  1431.  
  1432.  
  1433. /*
  1434.  * MESA_FORMAT_SIGNED_RG88_REV
  1435.  */
  1436.  
  1437. static void
  1438. pack_float_SIGNED_RG88_REV(const GLfloat src[4], void *dst)
  1439. {
  1440.    GLushort *d = (GLushort *) dst;
  1441.    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1442.    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1443.    *d = (g << 8) | r;
  1444. }
  1445.  
  1446.  
  1447. /*
  1448.  * MESA_FORMAT_SIGNED_RGBX8888
  1449.  */
  1450.  
  1451. static void
  1452. pack_float_SIGNED_RGBX8888(const GLfloat src[4], void *dst)
  1453. {
  1454.    GLuint *d = (GLuint *) dst;
  1455.    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1456.    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1457.    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1458.    GLbyte a = 127;
  1459.    *d = PACK_COLOR_8888(r, g, b, a);
  1460. }
  1461.  
  1462.  
  1463. /*
  1464.  * MESA_FORMAT_SIGNED_RGBA8888
  1465.  */
  1466.  
  1467. static void
  1468. pack_float_SIGNED_RGBA8888(const GLfloat src[4], void *dst)
  1469. {
  1470.    GLuint *d = (GLuint *) dst;
  1471.    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1472.    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1473.    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1474.    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1475.    *d = PACK_COLOR_8888(r, g, b, a);
  1476. }
  1477.  
  1478.  
  1479. /*
  1480.  * MESA_FORMAT_SIGNED_RGBA8888_REV
  1481.  */
  1482.  
  1483. static void
  1484. pack_float_SIGNED_RGBA8888_REV(const GLfloat src[4], void *dst)
  1485. {
  1486.    GLuint *d = (GLuint *) dst;
  1487.    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1488.    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1489.    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1490.    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1491.    *d = PACK_COLOR_8888(a, b, g, r);
  1492. }
  1493.  
  1494.  
  1495. /*
  1496.  * MESA_FORMAT_SIGNED_R16
  1497.  */
  1498.  
  1499. static void
  1500. pack_float_SIGNED_R16(const GLfloat src[4], void *dst)
  1501. {
  1502.    GLshort *d = (GLshort *) dst;
  1503.    *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1504. }
  1505.  
  1506.  
  1507. /*
  1508.  * MESA_FORMAT_SIGNED_GR1616
  1509.  */
  1510.  
  1511. static void
  1512. pack_float_SIGNED_GR1616(const GLfloat src[4], void *dst)
  1513. {
  1514.    GLuint *d = (GLuint *) dst;
  1515.    GLshort r = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1516.    GLshort g = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1517.    *d = (g << 16) | (r & 0xffff);
  1518. }
  1519.  
  1520.  
  1521. /*
  1522.  * MESA_FORMAT_SIGNED_RGB_16
  1523.  */
  1524.  
  1525. static void
  1526. pack_float_SIGNED_RGB_16(const GLfloat src[4], void *dst)
  1527. {
  1528.    GLshort *d = (GLshort *) dst;
  1529.    d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1530.    d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1531.    d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1532. }
  1533.  
  1534.  
  1535. /*
  1536.  * MESA_FORMAT_SIGNED_RGBA_16
  1537.  */
  1538.  
  1539. static void
  1540. pack_float_SIGNED_RGBA_16(const GLfloat src[4], void *dst)
  1541. {
  1542.    GLshort *d = (GLshort *) dst;
  1543.    d[0] = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1544.    d[1] = FLOAT_TO_SHORT(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1545.    d[2] = FLOAT_TO_SHORT(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1546.    d[3] = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1547. }
  1548.  
  1549.  
  1550. /*
  1551.  * MESA_FORMAT_SIGNED_A8
  1552.  */
  1553.  
  1554. static void
  1555. pack_float_SIGNED_A8(const GLfloat src[4], void *dst)
  1556. {
  1557.    GLbyte *d = (GLbyte *) dst;
  1558.    *d = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1559. }
  1560.  
  1561.  
  1562. /*
  1563.  * MESA_FORMAT_SIGNED_L8
  1564.  */
  1565.  
  1566. static void
  1567. pack_float_SIGNED_L8(const GLfloat src[4], void *dst)
  1568. {
  1569.    GLbyte *d = (GLbyte *) dst;
  1570.    *d = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1571. }
  1572.  
  1573.  
  1574. /*
  1575.  * MESA_FORMAT_SIGNED_AL88
  1576.  */
  1577.  
  1578. static void
  1579. pack_float_SIGNED_AL88(const GLfloat src[4], void *dst)
  1580. {
  1581.    GLushort *d = (GLushort *) dst;
  1582.    GLbyte l = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1583.    GLbyte a = FLOAT_TO_BYTE(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1584.    *d = (a << 8) | l;
  1585. }
  1586.  
  1587.  
  1588. /*
  1589.  * MESA_FORMAT_SIGNED_A16
  1590.  */
  1591.  
  1592. static void
  1593. pack_float_SIGNED_A16(const GLfloat src[4], void *dst)
  1594. {
  1595.    GLshort *d = (GLshort *) dst;
  1596.    *d = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1597. }
  1598.  
  1599.  
  1600. /*
  1601.  * MESA_FORMAT_SIGNED_L16
  1602.  */
  1603.  
  1604. static void
  1605. pack_float_SIGNED_L16(const GLfloat src[4], void *dst)
  1606. {
  1607.    GLshort *d = (GLshort *) dst;
  1608.    *d = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1609. }
  1610.  
  1611.  
  1612. /*
  1613.  * MESA_FORMAT_SIGNED_AL1616
  1614.  */
  1615.  
  1616. static void
  1617. pack_float_SIGNED_AL1616(const GLfloat src[4], void *dst)
  1618. {
  1619.    GLuint *d = (GLuint *) dst;
  1620.    GLshort l = FLOAT_TO_SHORT(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1621.    GLshort a = FLOAT_TO_SHORT(CLAMP(src[ACOMP], -1.0f, 1.0f));
  1622.    *d = PACK_COLOR_1616(a, l);
  1623. }
  1624.  
  1625.  
  1626. /*
  1627.  * MESA_FORMAT_RGB9_E5_FLOAT;
  1628.  */
  1629.  
  1630. static void
  1631. pack_float_RGB9_E5_FLOAT(const GLfloat src[4], void *dst)
  1632. {
  1633.    GLuint *d = (GLuint *) dst;
  1634.    *d = float3_to_rgb9e5(src);
  1635. }
  1636.  
  1637. static void
  1638. pack_ubyte_RGB9_E5_FLOAT(const GLubyte src[4], void *dst)
  1639. {
  1640.    GLuint *d = (GLuint *) dst;
  1641.    GLfloat rgb[3];
  1642.    rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
  1643.    rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
  1644.    rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
  1645.    *d = float3_to_rgb9e5(rgb);
  1646. }
  1647.  
  1648.  
  1649.  
  1650. /*
  1651.  * MESA_FORMAT_R11_G11_B10_FLOAT;
  1652.  */
  1653.  
  1654. static void
  1655. pack_ubyte_R11_G11_B10_FLOAT(const GLubyte src[4], void *dst)
  1656. {
  1657.    GLuint *d = (GLuint *) dst;
  1658.    GLfloat rgb[3];
  1659.    rgb[0] = UBYTE_TO_FLOAT(src[RCOMP]);
  1660.    rgb[1] = UBYTE_TO_FLOAT(src[GCOMP]);
  1661.    rgb[2] = UBYTE_TO_FLOAT(src[BCOMP]);
  1662.    *d = float3_to_r11g11b10f(rgb);
  1663. }
  1664.  
  1665. static void
  1666. pack_float_R11_G11_B10_FLOAT(const GLfloat src[4], void *dst)
  1667. {
  1668.    GLuint *d = (GLuint *) dst;
  1669.    *d = float3_to_r11g11b10f(src);
  1670. }
  1671.  
  1672.  
  1673. /*
  1674.  * MESA_FORMAT_XRGB4444_UNORM
  1675.  */
  1676.  
  1677. static void
  1678. pack_ubyte_XRGB4444_UNORM(const GLubyte src[4], void *dst)
  1679. {
  1680.    GLushort *d = ((GLushort *) dst);
  1681.    *d = PACK_COLOR_4444(255, src[RCOMP], src[GCOMP], src[BCOMP]);
  1682. }
  1683.  
  1684. static void
  1685. pack_float_XRGB4444_UNORM(const GLfloat src[4], void *dst)
  1686. {
  1687.    GLubyte v[4];
  1688.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  1689.    pack_ubyte_XRGB4444_UNORM(v, dst);
  1690. }
  1691.  
  1692.  
  1693. /*
  1694.  * MESA_FORMAT_XRGB1555_UNORM
  1695.  */
  1696.  
  1697. static void
  1698. pack_ubyte_XRGB1555_UNORM(const GLubyte src[4], void *dst)
  1699. {
  1700.    GLushort *d = ((GLushort *) dst);
  1701.    *d = PACK_COLOR_1555(255, src[RCOMP], src[GCOMP], src[BCOMP]);
  1702. }
  1703.  
  1704. static void
  1705. pack_float_XRGB1555_UNORM(const GLfloat src[4], void *dst)
  1706. {
  1707.    GLubyte v[4];
  1708.    _mesa_unclamped_float_rgba_to_ubyte(v, src);
  1709.    pack_ubyte_XRGB1555_UNORM(v, dst);
  1710. }
  1711.  
  1712.  
  1713. /*
  1714.  * MESA_FORMAT_XBGR8888_SNORM
  1715.  */
  1716.  
  1717. static void
  1718. pack_float_XBGR8888_SNORM(const GLfloat src[4], void *dst)
  1719. {
  1720.    GLuint *d = (GLuint *) dst;
  1721.    GLbyte r = FLOAT_TO_BYTE(CLAMP(src[RCOMP], -1.0f, 1.0f));
  1722.    GLbyte g = FLOAT_TO_BYTE(CLAMP(src[GCOMP], -1.0f, 1.0f));
  1723.    GLbyte b = FLOAT_TO_BYTE(CLAMP(src[BCOMP], -1.0f, 1.0f));
  1724.    *d = PACK_COLOR_8888(127, b, g, r);
  1725. }
  1726.  
  1727.  
  1728. /*
  1729.  * MESA_FORMAT_XBGR8888_SRGB
  1730.  */
  1731.  
  1732. static void
  1733. pack_float_XBGR8888_SRGB(const GLfloat src[4], void *dst)
  1734. {
  1735.    GLuint *d = (GLuint *) dst;
  1736.    GLubyte r = linear_float_to_srgb_ubyte(src[RCOMP]);
  1737.    GLubyte g = linear_float_to_srgb_ubyte(src[GCOMP]);
  1738.    GLubyte b = linear_float_to_srgb_ubyte(src[BCOMP]);
  1739.    *d = PACK_COLOR_8888(127, b, g, r);
  1740. }
  1741.  
  1742.  
  1743. /* MESA_FORMAT_XRGB2101010_UNORM */
  1744.  
  1745. static void
  1746. pack_ubyte_XRGB2101010_UNORM(const GLubyte src[4], void *dst)
  1747. {
  1748.    GLuint *d = ((GLuint *) dst);
  1749.    GLushort r = UBYTE_TO_USHORT(src[RCOMP]);
  1750.    GLushort g = UBYTE_TO_USHORT(src[GCOMP]);
  1751.    GLushort b = UBYTE_TO_USHORT(src[BCOMP]);
  1752.    *d = PACK_COLOR_2101010_US(3, r, g, b);
  1753. }
  1754.  
  1755. static void
  1756. pack_float_XRGB2101010_UNORM(const GLfloat src[4], void *dst)
  1757. {
  1758.    GLuint *d = ((GLuint *) dst);
  1759.    GLushort r, g, b;
  1760.    UNCLAMPED_FLOAT_TO_USHORT(r, src[RCOMP]);
  1761.    UNCLAMPED_FLOAT_TO_USHORT(g, src[GCOMP]);
  1762.    UNCLAMPED_FLOAT_TO_USHORT(b, src[BCOMP]);
  1763.    *d = PACK_COLOR_2101010_US(3, r, g, b);
  1764. }
  1765.  
  1766.  
  1767. /* MESA_FORMAT_XBGR16161616_UNORM */
  1768.  
  1769. static void
  1770. pack_ubyte_XBGR16161616_UNORM(const GLubyte src[4], void *dst)
  1771. {
  1772.    GLushort *d = ((GLushort *) dst);
  1773.    d[0] = UBYTE_TO_USHORT(src[RCOMP]);
  1774.    d[1] = UBYTE_TO_USHORT(src[GCOMP]);
  1775.    d[2] = UBYTE_TO_USHORT(src[BCOMP]);
  1776.    d[3] = 65535;
  1777. }
  1778.  
  1779. static void
  1780. pack_float_XBGR16161616_UNORM(const GLfloat src[4], void *dst)
  1781. {
  1782.    GLushort *d = ((GLushort *) dst);
  1783.    UNCLAMPED_FLOAT_TO_USHORT(d[0], src[RCOMP]);
  1784.    UNCLAMPED_FLOAT_TO_USHORT(d[1], src[GCOMP]);
  1785.    UNCLAMPED_FLOAT_TO_USHORT(d[2], src[BCOMP]);
  1786.    d[3] = 65535;
  1787. }
  1788.  
  1789.  
  1790. /* MESA_FORMAT_XBGR16161616_SNORM */
  1791.  
  1792. static void
  1793. pack_float_XBGR16161616_SNORM(const GLfloat src[4], void *dst)
  1794. {
  1795.    GLushort *d = ((GLushort *) dst);
  1796.    UNCLAMPED_FLOAT_TO_SHORT(d[0], src[RCOMP]);
  1797.    UNCLAMPED_FLOAT_TO_SHORT(d[1], src[GCOMP]);
  1798.    UNCLAMPED_FLOAT_TO_SHORT(d[2], src[BCOMP]);
  1799.    d[3] = 32767;
  1800. }
  1801.  
  1802.  
  1803. /* MESA_FORMAT_XBGR16161616_FLOAT */
  1804.  
  1805. static void
  1806. pack_float_XBGR16161616_FLOAT(const GLfloat src[4], void *dst)
  1807. {
  1808.    GLushort *d = ((GLushort *) dst);
  1809.    d[0] = _mesa_float_to_half(src[RCOMP]);
  1810.    d[1] = _mesa_float_to_half(src[GCOMP]);
  1811.    d[2] = _mesa_float_to_half(src[BCOMP]);
  1812.    d[3] = _mesa_float_to_half(1.0);
  1813. }
  1814.  
  1815. /* MESA_FORMAT_XBGR32323232_FLOAT */
  1816.  
  1817. static void
  1818. pack_float_XBGR32323232_FLOAT(const GLfloat src[4], void *dst)
  1819. {
  1820.    GLfloat *d = ((GLfloat *) dst);
  1821.    d[0] = src[RCOMP];
  1822.    d[1] = src[GCOMP];
  1823.    d[2] = src[BCOMP];
  1824.    d[3] = 1.0;
  1825. }
  1826.  
  1827.  
  1828. /**
  1829.  * Return a function that can pack a GLubyte rgba[4] color.
  1830.  */
  1831. gl_pack_ubyte_rgba_func
  1832. _mesa_get_pack_ubyte_rgba_function(gl_format format)
  1833. {
  1834.    static gl_pack_ubyte_rgba_func table[MESA_FORMAT_COUNT];
  1835.    static GLboolean initialized = GL_FALSE;
  1836.  
  1837.    if (!initialized) {
  1838.       memset(table, 0, sizeof(table));
  1839.  
  1840.       table[MESA_FORMAT_NONE] = NULL;
  1841.  
  1842.       table[MESA_FORMAT_RGBA8888] = pack_ubyte_RGBA8888;
  1843.       table[MESA_FORMAT_RGBA8888_REV] = pack_ubyte_RGBA8888_REV;
  1844.       table[MESA_FORMAT_ARGB8888] = pack_ubyte_ARGB8888;
  1845.       table[MESA_FORMAT_ARGB8888_REV] = pack_ubyte_ARGB8888_REV;
  1846.       table[MESA_FORMAT_RGBX8888] = pack_ubyte_RGBA8888; /* reused */
  1847.       table[MESA_FORMAT_RGBX8888_REV] = pack_ubyte_RGBA8888_REV; /* reused */
  1848.       table[MESA_FORMAT_XRGB8888] = pack_ubyte_XRGB8888;
  1849.       table[MESA_FORMAT_XRGB8888_REV] = pack_ubyte_XRGB8888_REV;
  1850.       table[MESA_FORMAT_RGB888] = pack_ubyte_RGB888;
  1851.       table[MESA_FORMAT_BGR888] = pack_ubyte_BGR888;
  1852.       table[MESA_FORMAT_RGB565] = pack_ubyte_RGB565;
  1853.       table[MESA_FORMAT_RGB565_REV] = pack_ubyte_RGB565_REV;
  1854.       table[MESA_FORMAT_ARGB4444] = pack_ubyte_ARGB4444;
  1855.       table[MESA_FORMAT_ARGB4444_REV] = pack_ubyte_ARGB4444_REV;
  1856.       table[MESA_FORMAT_RGBA5551] = pack_ubyte_RGBA5551;
  1857.       table[MESA_FORMAT_ARGB1555] = pack_ubyte_ARGB1555;
  1858.       table[MESA_FORMAT_ARGB1555_REV] = pack_ubyte_ARGB1555_REV;
  1859.       table[MESA_FORMAT_AL44] = pack_ubyte_AL44;
  1860.       table[MESA_FORMAT_AL88] = pack_ubyte_AL88;
  1861.       table[MESA_FORMAT_AL88_REV] = pack_ubyte_AL88_REV;
  1862.       table[MESA_FORMAT_AL1616] = pack_ubyte_AL1616;
  1863.       table[MESA_FORMAT_AL1616_REV] = pack_ubyte_AL1616_REV;
  1864.       table[MESA_FORMAT_RGB332] = pack_ubyte_RGB332;
  1865.       table[MESA_FORMAT_A8] = pack_ubyte_A8;
  1866.       table[MESA_FORMAT_A16] = pack_ubyte_A16;
  1867.       table[MESA_FORMAT_L8] = pack_ubyte_L8;
  1868.       table[MESA_FORMAT_L16] = pack_ubyte_L16;
  1869.       table[MESA_FORMAT_I8] = pack_ubyte_L8; /* reuse pack_ubyte_L8 */
  1870.       table[MESA_FORMAT_I16] = pack_ubyte_L16; /* reuse pack_ubyte_L16 */
  1871.       table[MESA_FORMAT_YCBCR] = pack_ubyte_YCBCR;
  1872.       table[MESA_FORMAT_YCBCR_REV] = pack_ubyte_YCBCR_REV;
  1873.       table[MESA_FORMAT_R8] = pack_ubyte_R8;
  1874.       table[MESA_FORMAT_GR88] = pack_ubyte_GR88;
  1875.       table[MESA_FORMAT_RG88] = pack_ubyte_RG88;
  1876.       table[MESA_FORMAT_R16] = pack_ubyte_R16;
  1877.       table[MESA_FORMAT_GR1616] = pack_ubyte_GR1616;
  1878.       table[MESA_FORMAT_RG1616] = pack_ubyte_RG1616;
  1879.       table[MESA_FORMAT_ARGB2101010] = pack_ubyte_ARGB2101010;
  1880.       table[MESA_FORMAT_ABGR2101010_UINT] = pack_ubyte_ABGR2101010_UINT;
  1881.  
  1882.       /* should never convert RGBA to these formats */
  1883.       table[MESA_FORMAT_Z24_S8] = NULL;
  1884.       table[MESA_FORMAT_S8_Z24] = NULL;
  1885.       table[MESA_FORMAT_Z16] = NULL;
  1886.       table[MESA_FORMAT_X8_Z24] = NULL;
  1887.       table[MESA_FORMAT_Z24_X8] = NULL;
  1888.       table[MESA_FORMAT_Z32] = NULL;
  1889.       table[MESA_FORMAT_S8] = NULL;
  1890.  
  1891.       /* sRGB */
  1892.       table[MESA_FORMAT_SRGB8] = pack_ubyte_SRGB8;
  1893.       table[MESA_FORMAT_SRGBA8] = pack_ubyte_SRGBA8;
  1894.       table[MESA_FORMAT_SARGB8] = pack_ubyte_SARGB8;
  1895.       table[MESA_FORMAT_SL8] = pack_ubyte_SL8;
  1896.       table[MESA_FORMAT_SLA8] = pack_ubyte_SLA8;
  1897.  
  1898.       /* n/a */
  1899.       table[MESA_FORMAT_SRGB_DXT1] = NULL; /* pack_ubyte_SRGB_DXT1; */
  1900.       table[MESA_FORMAT_SRGBA_DXT1] = NULL; /* pack_ubyte_SRGBA_DXT1; */
  1901.       table[MESA_FORMAT_SRGBA_DXT3] = NULL; /* pack_ubyte_SRGBA_DXT3; */
  1902.       table[MESA_FORMAT_SRGBA_DXT5] = NULL; /* pack_ubyte_SRGBA_DXT5; */
  1903.  
  1904.       table[MESA_FORMAT_RGB_FXT1] = NULL; /* pack_ubyte_RGB_FXT1; */
  1905.       table[MESA_FORMAT_RGBA_FXT1] = NULL; /* pack_ubyte_RGBA_FXT1; */
  1906.       table[MESA_FORMAT_RGB_DXT1] = NULL; /* pack_ubyte_RGB_DXT1; */
  1907.       table[MESA_FORMAT_RGBA_DXT1] = NULL; /* pack_ubyte_RGBA_DXT1; */
  1908.       table[MESA_FORMAT_RGBA_DXT3] = NULL; /* pack_ubyte_RGBA_DXT3; */
  1909.       table[MESA_FORMAT_RGBA_DXT5] = NULL; /* pack_ubyte_RGBA_DXT5; */
  1910.  
  1911.       table[MESA_FORMAT_RGBA_FLOAT32] = pack_ubyte_RGBA_FLOAT32;
  1912.       table[MESA_FORMAT_RGBA_FLOAT16] = pack_ubyte_RGBA_FLOAT16;
  1913.       table[MESA_FORMAT_RGB_FLOAT32] = pack_ubyte_RGB_FLOAT32;
  1914.       table[MESA_FORMAT_RGB_FLOAT16] = pack_ubyte_RGB_FLOAT16;
  1915.       table[MESA_FORMAT_ALPHA_FLOAT32] = pack_ubyte_ALPHA_FLOAT32;
  1916.       table[MESA_FORMAT_ALPHA_FLOAT16] = pack_ubyte_ALPHA_FLOAT16;
  1917.       table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
  1918.       table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
  1919.       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_ubyte_LUMINANCE_ALPHA_FLOAT32;
  1920.       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_ubyte_LUMINANCE_ALPHA_FLOAT16;
  1921.       table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
  1922.       table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
  1923.       table[MESA_FORMAT_R_FLOAT32] = pack_ubyte_LUMINANCE_FLOAT32;
  1924.       table[MESA_FORMAT_R_FLOAT16] = pack_ubyte_LUMINANCE_FLOAT16;
  1925.       table[MESA_FORMAT_RG_FLOAT32] = pack_ubyte_RG_FLOAT32;
  1926.       table[MESA_FORMAT_RG_FLOAT16] = pack_ubyte_RG_FLOAT16;
  1927.  
  1928.       /* n/a */
  1929.       table[MESA_FORMAT_RGBA_INT8] = NULL; /* pack_ubyte_RGBA_INT8 */
  1930.       table[MESA_FORMAT_RGBA_INT16] = NULL; /* pack_ubyte_RGBA_INT16 */
  1931.       table[MESA_FORMAT_RGBA_INT32] = NULL; /* pack_ubyte_RGBA_INT32 */
  1932.       table[MESA_FORMAT_RGBA_UINT8] = NULL; /* pack_ubyte_RGBA_UINT8 */
  1933.       table[MESA_FORMAT_RGBA_UINT16] = NULL; /* pack_ubyte_RGBA_UINT16 */
  1934.       table[MESA_FORMAT_RGBA_UINT32] = NULL; /* pack_ubyte_RGBA_UINT32 */
  1935.  
  1936.       table[MESA_FORMAT_DUDV8] = pack_ubyte_DUDV8;
  1937.  
  1938.       table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
  1939.  
  1940.       /* n/a */
  1941.       table[MESA_FORMAT_SIGNED_R8] = NULL;
  1942.       table[MESA_FORMAT_SIGNED_RG88_REV] = NULL;
  1943.       table[MESA_FORMAT_SIGNED_RGBX8888] = NULL;
  1944.       table[MESA_FORMAT_SIGNED_RGBA8888] = NULL;
  1945.       table[MESA_FORMAT_SIGNED_RGBA8888_REV] = NULL;
  1946.       table[MESA_FORMAT_SIGNED_R16] = NULL;
  1947.       table[MESA_FORMAT_SIGNED_GR1616] = NULL;
  1948.       table[MESA_FORMAT_SIGNED_RGB_16] = NULL;
  1949.       table[MESA_FORMAT_SIGNED_RGBA_16] = NULL;
  1950.       table[MESA_FORMAT_SIGNED_A8] = NULL;
  1951.       table[MESA_FORMAT_SIGNED_L8] = NULL;
  1952.       table[MESA_FORMAT_SIGNED_AL88] = NULL;
  1953.       table[MESA_FORMAT_SIGNED_I8] = NULL;
  1954.       table[MESA_FORMAT_SIGNED_A16] = NULL;
  1955.       table[MESA_FORMAT_SIGNED_L16] = NULL;
  1956.       table[MESA_FORMAT_SIGNED_AL1616] = NULL;
  1957.       table[MESA_FORMAT_SIGNED_I16] = NULL;
  1958.  
  1959.  
  1960.       table[MESA_FORMAT_RGBA_16] = pack_ubyte_RGBA_16;
  1961.  
  1962.       table[MESA_FORMAT_RGB9_E5_FLOAT] = pack_ubyte_RGB9_E5_FLOAT;
  1963.       table[MESA_FORMAT_R11_G11_B10_FLOAT] = pack_ubyte_R11_G11_B10_FLOAT;
  1964.  
  1965.       table[MESA_FORMAT_XRGB4444_UNORM] = pack_ubyte_XRGB4444_UNORM;
  1966.       table[MESA_FORMAT_XRGB1555_UNORM] = pack_ubyte_XRGB1555_UNORM;
  1967.       table[MESA_FORMAT_XBGR8888_SNORM] = NULL;
  1968.       table[MESA_FORMAT_XBGR8888_SRGB] = NULL;
  1969.       table[MESA_FORMAT_XBGR8888_UINT] = NULL;
  1970.       table[MESA_FORMAT_XBGR8888_SINT] = NULL;
  1971.       table[MESA_FORMAT_XRGB2101010_UNORM] = pack_ubyte_XRGB2101010_UNORM;
  1972.       table[MESA_FORMAT_XBGR16161616_UNORM] = pack_ubyte_XBGR16161616_UNORM;
  1973.       table[MESA_FORMAT_XBGR16161616_SNORM] = NULL;
  1974.       table[MESA_FORMAT_XBGR16161616_FLOAT] = NULL;
  1975.       table[MESA_FORMAT_XBGR16161616_UINT] = NULL;
  1976.       table[MESA_FORMAT_XBGR16161616_SINT] = NULL;
  1977.       table[MESA_FORMAT_XBGR32323232_FLOAT] = NULL;
  1978.       table[MESA_FORMAT_XBGR32323232_UINT] = NULL;
  1979.       table[MESA_FORMAT_XBGR32323232_SINT] = NULL;
  1980.  
  1981.       initialized = GL_TRUE;
  1982.    }
  1983.  
  1984.    return table[format];
  1985. }
  1986.  
  1987.  
  1988.  
  1989. /**
  1990.  * Return a function that can pack a GLfloat rgba[4] color.
  1991.  */
  1992. gl_pack_float_rgba_func
  1993. _mesa_get_pack_float_rgba_function(gl_format format)
  1994. {
  1995.    static gl_pack_float_rgba_func table[MESA_FORMAT_COUNT];
  1996.    static GLboolean initialized = GL_FALSE;
  1997.  
  1998.    if (!initialized) {
  1999.       memset(table, 0, sizeof(table));
  2000.  
  2001.       table[MESA_FORMAT_NONE] = NULL;
  2002.  
  2003.       table[MESA_FORMAT_RGBA8888] = pack_float_RGBA8888;
  2004.       table[MESA_FORMAT_RGBA8888_REV] = pack_float_RGBA8888_REV;
  2005.       table[MESA_FORMAT_ARGB8888] = pack_float_ARGB8888;
  2006.       table[MESA_FORMAT_ARGB8888_REV] = pack_float_ARGB8888_REV;
  2007.       table[MESA_FORMAT_RGBX8888] = pack_float_RGBA8888; /* reused */
  2008.       table[MESA_FORMAT_RGBX8888_REV] = pack_float_RGBA8888_REV; /* reused */
  2009.       table[MESA_FORMAT_XRGB8888] = pack_float_XRGB8888;
  2010.       table[MESA_FORMAT_XRGB8888_REV] = pack_float_XRGB8888_REV;
  2011.       table[MESA_FORMAT_RGB888] = pack_float_RGB888;
  2012.       table[MESA_FORMAT_BGR888] = pack_float_BGR888;
  2013.       table[MESA_FORMAT_RGB565] = pack_float_RGB565;
  2014.       table[MESA_FORMAT_RGB565_REV] = pack_float_RGB565_REV;
  2015.       table[MESA_FORMAT_ARGB4444] = pack_float_ARGB4444;
  2016.       table[MESA_FORMAT_ARGB4444_REV] = pack_float_ARGB4444_REV;
  2017.       table[MESA_FORMAT_RGBA5551] = pack_float_RGBA5551;
  2018.       table[MESA_FORMAT_ARGB1555] = pack_float_ARGB1555;
  2019.       table[MESA_FORMAT_ARGB1555_REV] = pack_float_ARGB1555_REV;
  2020.  
  2021.       table[MESA_FORMAT_AL44] = pack_float_AL44;
  2022.       table[MESA_FORMAT_AL88] = pack_float_AL88;
  2023.       table[MESA_FORMAT_AL88_REV] = pack_float_AL88_REV;
  2024.       table[MESA_FORMAT_AL1616] = pack_float_AL1616;
  2025.       table[MESA_FORMAT_AL1616_REV] = pack_float_AL1616_REV;
  2026.       table[MESA_FORMAT_RGB332] = pack_float_RGB332;
  2027.       table[MESA_FORMAT_A8] = pack_float_A8;
  2028.       table[MESA_FORMAT_A16] = pack_float_A16;
  2029.       table[MESA_FORMAT_L8] = pack_float_L8;
  2030.       table[MESA_FORMAT_L16] = pack_float_L16;
  2031.       table[MESA_FORMAT_I8] = pack_float_L8; /* reuse pack_float_L8 */
  2032.       table[MESA_FORMAT_I16] = pack_float_L16; /* reuse pack_float_L16 */
  2033.       table[MESA_FORMAT_YCBCR] = pack_float_YCBCR;
  2034.       table[MESA_FORMAT_YCBCR_REV] = pack_float_YCBCR_REV;
  2035.       table[MESA_FORMAT_R8] = pack_float_R8;
  2036.       table[MESA_FORMAT_GR88] = pack_float_GR88;
  2037.       table[MESA_FORMAT_RG88] = pack_float_RG88;
  2038.       table[MESA_FORMAT_R16] = pack_float_R16;
  2039.       table[MESA_FORMAT_GR1616] = pack_float_GR1616;
  2040.       table[MESA_FORMAT_RG1616] = pack_float_RG1616;
  2041.       table[MESA_FORMAT_ARGB2101010] = pack_float_ARGB2101010;
  2042.       table[MESA_FORMAT_ABGR2101010_UINT] = pack_float_ABGR2101010_UINT;
  2043.  
  2044.       /* should never convert RGBA to these formats */
  2045.       table[MESA_FORMAT_Z24_S8] = NULL;
  2046.       table[MESA_FORMAT_S8_Z24] = NULL;
  2047.       table[MESA_FORMAT_Z16] = NULL;
  2048.       table[MESA_FORMAT_X8_Z24] = NULL;
  2049.       table[MESA_FORMAT_Z24_X8] = NULL;
  2050.       table[MESA_FORMAT_Z32] = NULL;
  2051.       table[MESA_FORMAT_S8] = NULL;
  2052.  
  2053.       table[MESA_FORMAT_SRGB8] = pack_float_SRGB8;
  2054.       table[MESA_FORMAT_SRGBA8] = pack_float_SRGBA8;
  2055.       table[MESA_FORMAT_SARGB8] = pack_float_SARGB8;
  2056.       table[MESA_FORMAT_SL8] = pack_float_SL8;
  2057.       table[MESA_FORMAT_SLA8] = pack_float_SLA8;
  2058.  
  2059.       /* n/a */
  2060.       table[MESA_FORMAT_SRGB_DXT1] = NULL;
  2061.       table[MESA_FORMAT_SRGBA_DXT1] = NULL;
  2062.       table[MESA_FORMAT_SRGBA_DXT3] = NULL;
  2063.       table[MESA_FORMAT_SRGBA_DXT5] = NULL;
  2064.  
  2065.       table[MESA_FORMAT_RGB_FXT1] = NULL;
  2066.       table[MESA_FORMAT_RGBA_FXT1] = NULL;
  2067.       table[MESA_FORMAT_RGB_DXT1] = NULL;
  2068.       table[MESA_FORMAT_RGBA_DXT1] = NULL;
  2069.       table[MESA_FORMAT_RGBA_DXT3] = NULL;
  2070.       table[MESA_FORMAT_RGBA_DXT5] = NULL;
  2071.  
  2072.       table[MESA_FORMAT_RGBA_FLOAT32] = pack_float_RGBA_FLOAT32;
  2073.       table[MESA_FORMAT_RGBA_FLOAT16] = pack_float_RGBA_FLOAT16;
  2074.       table[MESA_FORMAT_RGB_FLOAT32] = pack_float_RGB_FLOAT32;
  2075.       table[MESA_FORMAT_RGB_FLOAT16] = pack_float_RGB_FLOAT16;
  2076.       table[MESA_FORMAT_ALPHA_FLOAT32] = pack_float_ALPHA_FLOAT32;
  2077.       table[MESA_FORMAT_ALPHA_FLOAT16] = pack_float_ALPHA_FLOAT16;
  2078.       table[MESA_FORMAT_LUMINANCE_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
  2079.       table[MESA_FORMAT_LUMINANCE_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
  2080.       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32] = pack_float_LUMINANCE_ALPHA_FLOAT32;
  2081.       table[MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16] = pack_float_LUMINANCE_ALPHA_FLOAT16;
  2082.  
  2083.       table[MESA_FORMAT_INTENSITY_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
  2084.       table[MESA_FORMAT_INTENSITY_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
  2085.       table[MESA_FORMAT_R_FLOAT32] = pack_float_LUMINANCE_FLOAT32;
  2086.       table[MESA_FORMAT_R_FLOAT16] = pack_float_LUMINANCE_FLOAT16;
  2087.       table[MESA_FORMAT_RG_FLOAT32] = pack_float_RG_FLOAT32;
  2088.       table[MESA_FORMAT_RG_FLOAT16] = pack_float_RG_FLOAT16;
  2089.  
  2090.       /* n/a */
  2091.       table[MESA_FORMAT_RGBA_INT8] = NULL;
  2092.       table[MESA_FORMAT_RGBA_INT16] = NULL;
  2093.       table[MESA_FORMAT_RGBA_INT32] = NULL;
  2094.       table[MESA_FORMAT_RGBA_UINT8] = NULL;
  2095.       table[MESA_FORMAT_RGBA_UINT16] = NULL;
  2096.       table[MESA_FORMAT_RGBA_UINT32] = NULL;
  2097.  
  2098.       table[MESA_FORMAT_DUDV8] = pack_float_DUDV8;
  2099.  
  2100.       table[MESA_FORMAT_RGBA_16] = pack_float_RGBA_16;
  2101.  
  2102.       table[MESA_FORMAT_SIGNED_R8] = pack_float_SIGNED_R8;
  2103.       table[MESA_FORMAT_SIGNED_RG88_REV] = pack_float_SIGNED_RG88_REV;
  2104.       table[MESA_FORMAT_SIGNED_RGBX8888] = pack_float_SIGNED_RGBX8888;
  2105.       table[MESA_FORMAT_SIGNED_RGBA8888] = pack_float_SIGNED_RGBA8888;
  2106.       table[MESA_FORMAT_SIGNED_RGBA8888_REV] = pack_float_SIGNED_RGBA8888_REV;
  2107.       table[MESA_FORMAT_SIGNED_R16] = pack_float_SIGNED_R16;
  2108.       table[MESA_FORMAT_SIGNED_GR1616] = pack_float_SIGNED_GR1616;
  2109.       table[MESA_FORMAT_SIGNED_RGB_16] = pack_float_SIGNED_RGB_16;
  2110.       table[MESA_FORMAT_SIGNED_RGBA_16] = pack_float_SIGNED_RGBA_16;
  2111.       table[MESA_FORMAT_SIGNED_A8] = pack_float_SIGNED_A8;
  2112.       table[MESA_FORMAT_SIGNED_L8] = pack_float_SIGNED_L8;
  2113.       table[MESA_FORMAT_SIGNED_AL88] = pack_float_SIGNED_AL88;
  2114.       table[MESA_FORMAT_SIGNED_I8] = pack_float_SIGNED_L8; /* reused */
  2115.       table[MESA_FORMAT_SIGNED_A16] = pack_float_SIGNED_A16;
  2116.       table[MESA_FORMAT_SIGNED_L16] = pack_float_SIGNED_L16;
  2117.       table[MESA_FORMAT_SIGNED_AL1616] = pack_float_SIGNED_AL1616;
  2118.       table[MESA_FORMAT_SIGNED_I16] = pack_float_SIGNED_L16; /* reused */
  2119.  
  2120.       table[MESA_FORMAT_RGB9_E5_FLOAT] = pack_float_RGB9_E5_FLOAT;
  2121.       table[MESA_FORMAT_R11_G11_B10_FLOAT] = pack_float_R11_G11_B10_FLOAT;
  2122.  
  2123.       table[MESA_FORMAT_XRGB4444_UNORM] = pack_float_XRGB4444_UNORM;
  2124.       table[MESA_FORMAT_XRGB1555_UNORM] = pack_float_XRGB1555_UNORM;
  2125.       table[MESA_FORMAT_XBGR8888_SNORM] = pack_float_XBGR8888_SNORM;
  2126.       table[MESA_FORMAT_XBGR8888_SRGB] = pack_float_XBGR8888_SRGB;
  2127.       table[MESA_FORMAT_XBGR8888_UINT] = NULL;
  2128.       table[MESA_FORMAT_XBGR8888_SINT] = NULL;
  2129.       table[MESA_FORMAT_XRGB2101010_UNORM] = pack_float_XRGB2101010_UNORM;
  2130.       table[MESA_FORMAT_XBGR16161616_UNORM] = pack_float_XBGR16161616_UNORM;
  2131.       table[MESA_FORMAT_XBGR16161616_SNORM] = pack_float_XBGR16161616_SNORM;
  2132.       table[MESA_FORMAT_XBGR16161616_FLOAT] = pack_float_XBGR16161616_FLOAT;
  2133.       table[MESA_FORMAT_XBGR16161616_UINT] = NULL;
  2134.       table[MESA_FORMAT_XBGR16161616_SINT] = NULL;
  2135.       table[MESA_FORMAT_XBGR32323232_FLOAT] = pack_float_XBGR32323232_FLOAT;
  2136.       table[MESA_FORMAT_XBGR32323232_UINT] = NULL;
  2137.       table[MESA_FORMAT_XBGR32323232_SINT] = NULL;
  2138.  
  2139.       initialized = GL_TRUE;
  2140.    }
  2141.  
  2142.    return table[format];
  2143. }
  2144.  
  2145.  
  2146.  
  2147. static pack_float_rgba_row_func
  2148. get_pack_float_rgba_row_function(gl_format format)
  2149. {
  2150.    static pack_float_rgba_row_func table[MESA_FORMAT_COUNT];
  2151.    static GLboolean initialized = GL_FALSE;
  2152.  
  2153.    if (!initialized) {
  2154.       /* We don't need a special row packing function for each format.
  2155.        * There's a generic fallback which uses a per-pixel packing function.
  2156.        */
  2157.       memset(table, 0, sizeof(table));
  2158.  
  2159.       table[MESA_FORMAT_RGBA8888] = pack_row_float_RGBA8888;
  2160.       table[MESA_FORMAT_RGBA8888_REV] = pack_row_float_RGBA8888_REV;
  2161.       table[MESA_FORMAT_ARGB8888] = pack_row_float_ARGB8888;
  2162.       table[MESA_FORMAT_ARGB8888_REV] = pack_row_float_ARGB8888_REV;
  2163.       table[MESA_FORMAT_RGBX8888] = pack_row_float_RGBA8888; /* reused */
  2164.       table[MESA_FORMAT_RGBX8888_REV] = pack_row_float_RGBA8888_REV; /* reused */
  2165.       table[MESA_FORMAT_XRGB8888] = pack_row_float_XRGB8888;
  2166.       table[MESA_FORMAT_XRGB8888_REV] = pack_row_float_XRGB8888_REV;
  2167.       table[MESA_FORMAT_RGB888] = pack_row_float_RGB888;
  2168.       table[MESA_FORMAT_BGR888] = pack_row_float_BGR888;
  2169.       table[MESA_FORMAT_RGB565] = pack_row_float_RGB565;
  2170.       table[MESA_FORMAT_RGB565_REV] = pack_row_float_RGB565_REV;
  2171.  
  2172.       initialized = GL_TRUE;
  2173.    }
  2174.  
  2175.    return table[format];
  2176. }
  2177.  
  2178.  
  2179.  
  2180. static pack_ubyte_rgba_row_func
  2181. get_pack_ubyte_rgba_row_function(gl_format format)
  2182. {
  2183.    static pack_ubyte_rgba_row_func table[MESA_FORMAT_COUNT];
  2184.    static GLboolean initialized = GL_FALSE;
  2185.  
  2186.    if (!initialized) {
  2187.       /* We don't need a special row packing function for each format.
  2188.        * There's a generic fallback which uses a per-pixel packing function.
  2189.        */
  2190.       memset(table, 0, sizeof(table));
  2191.  
  2192.       table[MESA_FORMAT_RGBA8888] = pack_row_ubyte_RGBA8888;
  2193.       table[MESA_FORMAT_RGBA8888_REV] = pack_row_ubyte_RGBA8888_REV;
  2194.       table[MESA_FORMAT_ARGB8888] = pack_row_ubyte_ARGB8888;
  2195.       table[MESA_FORMAT_ARGB8888_REV] = pack_row_ubyte_ARGB8888_REV;
  2196.       table[MESA_FORMAT_RGBX8888] = pack_row_ubyte_RGBA8888; /* reused */
  2197.       table[MESA_FORMAT_RGBX8888_REV] = pack_row_ubyte_RGBA8888_REV; /* reused */
  2198.       table[MESA_FORMAT_XRGB8888] = pack_row_ubyte_XRGB8888;
  2199.       table[MESA_FORMAT_XRGB8888_REV] = pack_row_ubyte_XRGB8888_REV;
  2200.       table[MESA_FORMAT_RGB888] = pack_row_ubyte_RGB888;
  2201.       table[MESA_FORMAT_BGR888] = pack_row_ubyte_BGR888;
  2202.       table[MESA_FORMAT_RGB565] = pack_row_ubyte_RGB565;
  2203.       table[MESA_FORMAT_RGB565_REV] = pack_row_ubyte_RGB565_REV;
  2204.  
  2205.       initialized = GL_TRUE;
  2206.    }
  2207.  
  2208.    return table[format];
  2209. }
  2210.  
  2211.  
  2212.  
  2213. /**
  2214.  * Pack a row of GLfloat rgba[4] values to the destination.
  2215.  */
  2216. void
  2217. _mesa_pack_float_rgba_row(gl_format format, GLuint n,
  2218.                           const GLfloat src[][4], void *dst)
  2219. {
  2220.    pack_float_rgba_row_func packrow = get_pack_float_rgba_row_function(format);
  2221.    if (packrow) {
  2222.       /* use "fast" function */
  2223.       packrow(n, src, dst);
  2224.    }
  2225.    else {
  2226.       /* slower fallback */
  2227.       gl_pack_float_rgba_func pack = _mesa_get_pack_float_rgba_function(format);
  2228.       GLuint dstStride = _mesa_get_format_bytes(format);
  2229.       GLubyte *dstPtr = (GLubyte *) dst;
  2230.       GLuint i;
  2231.  
  2232.       assert(pack);
  2233.       if (!pack)
  2234.          return;
  2235.  
  2236.       for (i = 0; i < n; i++) {
  2237.          pack(src[i], dstPtr);
  2238.          dstPtr += dstStride;
  2239.       }
  2240.    }
  2241. }
  2242.  
  2243.  
  2244. /**
  2245.  * Pack a row of GLubyte rgba[4] values to the destination.
  2246.  */
  2247. void
  2248. _mesa_pack_ubyte_rgba_row(gl_format format, GLuint n,
  2249.                           const GLubyte src[][4], void *dst)
  2250. {
  2251.    pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
  2252.    if (packrow) {
  2253.       /* use "fast" function */
  2254.       packrow(n, src, dst);
  2255.    }
  2256.    else {
  2257.       /* slower fallback */
  2258.       gl_pack_ubyte_rgba_func pack = _mesa_get_pack_ubyte_rgba_function(format);
  2259.       const GLuint stride = _mesa_get_format_bytes(format);
  2260.       GLubyte *d = ((GLubyte *) dst);
  2261.       GLuint i;
  2262.  
  2263.       assert(pack);
  2264.       if (!pack)
  2265.          return;
  2266.  
  2267.       for (i = 0; i < n; i++) {
  2268.          pack(src[i], d);
  2269.          d += stride;
  2270.       }
  2271.    }
  2272. }
  2273.  
  2274.  
  2275. /**
  2276.  * Pack a 2D image of ubyte RGBA pixels in the given format.
  2277.  * \param srcRowStride  source image row stride in bytes
  2278.  * \param dstRowStride  destination image row stride in bytes
  2279.  */
  2280. void
  2281. _mesa_pack_ubyte_rgba_rect(gl_format format, GLuint width, GLuint height,
  2282.                            const GLubyte *src, GLint srcRowStride,
  2283.                            void *dst, GLint dstRowStride)
  2284. {
  2285.    pack_ubyte_rgba_row_func packrow = get_pack_ubyte_rgba_row_function(format);
  2286.    GLubyte *dstUB = (GLubyte *) dst;
  2287.    GLuint i;
  2288.  
  2289.    if (packrow) {
  2290.       if (srcRowStride == width * 4 * sizeof(GLubyte) &&
  2291.           dstRowStride == _mesa_format_row_stride(format, width)) {
  2292.          /* do whole image at once */
  2293.          packrow(width * height, (const GLubyte (*)[4]) src, dst);
  2294.       }
  2295.       else {
  2296.          /* row by row */
  2297.          for (i = 0; i < height; i++) {
  2298.             packrow(width, (const GLubyte (*)[4]) src, dstUB);
  2299.             src += srcRowStride;
  2300.             dstUB += dstRowStride;
  2301.          }
  2302.       }
  2303.    }
  2304.    else {
  2305.       /* slower fallback */
  2306.       for (i = 0; i < height; i++) {
  2307.          _mesa_pack_ubyte_rgba_row(format, width,
  2308.                                    (const GLubyte (*)[4]) src, dstUB);
  2309.          src += srcRowStride;
  2310.          dstUB += dstRowStride;
  2311.       }
  2312.    }
  2313. }
  2314.  
  2315.  
  2316.  
  2317. /**
  2318.  ** Pack float Z pixels
  2319.  **/
  2320.  
  2321. static void
  2322. pack_float_z_Z24_S8(const GLfloat *src, void *dst)
  2323. {
  2324.    /* don't disturb the stencil values */
  2325.    GLuint *d = ((GLuint *) dst);
  2326.    const GLdouble scale = (GLdouble) 0xffffff;
  2327.    GLuint s = *d & 0xff;
  2328.    GLuint z = (GLuint) (*src * scale);
  2329.    assert(z <= 0xffffff);
  2330.    *d = (z << 8) | s;
  2331. }
  2332.  
  2333. static void
  2334. pack_float_z_S8_Z24(const GLfloat *src, void *dst)
  2335. {
  2336.    /* don't disturb the stencil values */
  2337.    GLuint *d = ((GLuint *) dst);
  2338.    const GLdouble scale = (GLdouble) 0xffffff;
  2339.    GLuint s = *d & 0xff000000;
  2340.    GLuint z = (GLuint) (*src * scale);
  2341.    assert(z <= 0xffffff);
  2342.    *d = s | z;
  2343. }
  2344.  
  2345. static void
  2346. pack_float_z_Z16(const GLfloat *src, void *dst)
  2347. {
  2348.    GLushort *d = ((GLushort *) dst);
  2349.    const GLfloat scale = (GLfloat) 0xffff;
  2350.    *d = (GLushort) (*src * scale);
  2351. }
  2352.  
  2353. static void
  2354. pack_float_z_Z32(const GLfloat *src, void *dst)
  2355. {
  2356.    GLuint *d = ((GLuint *) dst);
  2357.    const GLdouble scale = (GLdouble) 0xffffffff;
  2358.    *d = (GLuint) (*src * scale);
  2359. }
  2360.  
  2361. static void
  2362. pack_float_z_Z32_FLOAT(const GLfloat *src, void *dst)
  2363. {
  2364.    GLfloat *d = (GLfloat *) dst;
  2365.    *d = *src;
  2366. }
  2367.  
  2368. gl_pack_float_z_func
  2369. _mesa_get_pack_float_z_func(gl_format format)
  2370. {
  2371.    switch (format) {
  2372.    case MESA_FORMAT_Z24_S8:
  2373.    case MESA_FORMAT_Z24_X8:
  2374.       return pack_float_z_Z24_S8;
  2375.    case MESA_FORMAT_S8_Z24:
  2376.    case MESA_FORMAT_X8_Z24:
  2377.       return pack_float_z_S8_Z24;
  2378.    case MESA_FORMAT_Z16:
  2379.       return pack_float_z_Z16;
  2380.    case MESA_FORMAT_Z32:
  2381.       return pack_float_z_Z32;
  2382.    case MESA_FORMAT_Z32_FLOAT:
  2383.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2384.       return pack_float_z_Z32_FLOAT;
  2385.    default:
  2386.       _mesa_problem(NULL,
  2387.                     "unexpected format in _mesa_get_pack_float_z_func()");
  2388.       return NULL;
  2389.    }
  2390. }
  2391.  
  2392.  
  2393.  
  2394. /**
  2395.  ** Pack uint Z pixels.  The incoming src value is always in
  2396.  ** the range [0, 2^32-1].
  2397.  **/
  2398.  
  2399. static void
  2400. pack_uint_z_Z24_S8(const GLuint *src, void *dst)
  2401. {
  2402.    /* don't disturb the stencil values */
  2403.    GLuint *d = ((GLuint *) dst);
  2404.    GLuint s = *d & 0xff;
  2405.    GLuint z = *src & 0xffffff00;
  2406.    *d = z | s;
  2407. }
  2408.  
  2409. static void
  2410. pack_uint_z_S8_Z24(const GLuint *src, void *dst)
  2411. {
  2412.    /* don't disturb the stencil values */
  2413.    GLuint *d = ((GLuint *) dst);
  2414.    GLuint s = *d & 0xff000000;
  2415.    GLuint z = *src >> 8;
  2416.    *d = s | z;
  2417. }
  2418.  
  2419. static void
  2420. pack_uint_z_Z16(const GLuint *src, void *dst)
  2421. {
  2422.    GLushort *d = ((GLushort *) dst);
  2423.    *d = *src >> 16;
  2424. }
  2425.  
  2426. static void
  2427. pack_uint_z_Z32(const GLuint *src, void *dst)
  2428. {
  2429.    GLuint *d = ((GLuint *) dst);
  2430.    *d = *src;
  2431. }
  2432.  
  2433. static void
  2434. pack_uint_z_Z32_FLOAT(const GLuint *src, void *dst)
  2435. {
  2436.    GLuint *d = ((GLuint *) dst);
  2437.    const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
  2438.    *d = (GLuint) (*src * scale);
  2439.    assert(*d >= 0.0f);
  2440.    assert(*d <= 1.0f);
  2441. }
  2442.  
  2443. static void
  2444. pack_uint_z_Z32_FLOAT_X24S8(const GLuint *src, void *dst)
  2445. {
  2446.    GLfloat *d = ((GLfloat *) dst);
  2447.    const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
  2448.    *d = (GLfloat) (*src * scale);
  2449.    assert(*d >= 0.0f);
  2450.    assert(*d <= 1.0f);
  2451. }
  2452.  
  2453. gl_pack_uint_z_func
  2454. _mesa_get_pack_uint_z_func(gl_format format)
  2455. {
  2456.    switch (format) {
  2457.    case MESA_FORMAT_Z24_S8:
  2458.    case MESA_FORMAT_Z24_X8:
  2459.       return pack_uint_z_Z24_S8;
  2460.    case MESA_FORMAT_S8_Z24:
  2461.    case MESA_FORMAT_X8_Z24:
  2462.       return pack_uint_z_S8_Z24;
  2463.    case MESA_FORMAT_Z16:
  2464.       return pack_uint_z_Z16;
  2465.    case MESA_FORMAT_Z32:
  2466.       return pack_uint_z_Z32;
  2467.    case MESA_FORMAT_Z32_FLOAT:
  2468.       return pack_uint_z_Z32_FLOAT;
  2469.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2470.       return pack_uint_z_Z32_FLOAT_X24S8;
  2471.    default:
  2472.       _mesa_problem(NULL, "unexpected format in _mesa_get_pack_uint_z_func()");
  2473.       return NULL;
  2474.    }
  2475. }
  2476.  
  2477.  
  2478. /**
  2479.  ** Pack ubyte stencil pixels
  2480.  **/
  2481.  
  2482. static void
  2483. pack_ubyte_stencil_Z24_S8(const GLubyte *src, void *dst)
  2484. {
  2485.    /* don't disturb the Z values */
  2486.    GLuint *d = ((GLuint *) dst);
  2487.    GLuint s = *src;
  2488.    GLuint z = *d & 0xffffff00;
  2489.    *d = z | s;
  2490. }
  2491.  
  2492. static void
  2493. pack_ubyte_stencil_S8_Z24(const GLubyte *src, void *dst)
  2494. {
  2495.    /* don't disturb the Z values */
  2496.    GLuint *d = ((GLuint *) dst);
  2497.    GLuint s = *src << 24;
  2498.    GLuint z = *d & 0xffffff;
  2499.    *d = s | z;
  2500. }
  2501.  
  2502. static void
  2503. pack_ubyte_stencil_S8(const GLubyte *src, void *dst)
  2504. {
  2505.    GLubyte *d = (GLubyte *) dst;
  2506.    *d = *src;
  2507. }
  2508.  
  2509. static void
  2510. pack_ubyte_stencil_Z32_FLOAT_X24S8(const GLubyte *src, void *dst)
  2511. {
  2512.    GLfloat *d = ((GLfloat *) dst);
  2513.    d[1] = *src;
  2514. }
  2515.  
  2516.  
  2517. gl_pack_ubyte_stencil_func
  2518. _mesa_get_pack_ubyte_stencil_func(gl_format format)
  2519. {
  2520.    switch (format) {
  2521.    case MESA_FORMAT_Z24_S8:
  2522.       return pack_ubyte_stencil_Z24_S8;
  2523.    case MESA_FORMAT_S8_Z24:
  2524.       return pack_ubyte_stencil_S8_Z24;
  2525.    case MESA_FORMAT_S8:
  2526.       return pack_ubyte_stencil_S8;
  2527.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2528.       return pack_ubyte_stencil_Z32_FLOAT_X24S8;
  2529.    default:
  2530.       _mesa_problem(NULL,
  2531.                     "unexpected format in _mesa_pack_ubyte_stencil_func()");
  2532.       return NULL;
  2533.    }
  2534. }
  2535.  
  2536.  
  2537.  
  2538. void
  2539. _mesa_pack_float_z_row(gl_format format, GLuint n,
  2540.                        const GLfloat *src, void *dst)
  2541. {
  2542.    switch (format) {
  2543.    case MESA_FORMAT_Z24_S8:
  2544.    case MESA_FORMAT_Z24_X8:
  2545.       {
  2546.          /* don't disturb the stencil values */
  2547.          GLuint *d = ((GLuint *) dst);
  2548.          const GLdouble scale = (GLdouble) 0xffffff;
  2549.          GLuint i;
  2550.          for (i = 0; i < n; i++) {
  2551.             GLuint s = d[i] & 0xff;
  2552.             GLuint z = (GLuint) (src[i] * scale);
  2553.             assert(z <= 0xffffff);
  2554.             d[i] = (z << 8) | s;
  2555.          }
  2556.       }
  2557.       break;
  2558.    case MESA_FORMAT_S8_Z24:
  2559.    case MESA_FORMAT_X8_Z24:
  2560.       {
  2561.          /* don't disturb the stencil values */
  2562.          GLuint *d = ((GLuint *) dst);
  2563.          const GLdouble scale = (GLdouble) 0xffffff;
  2564.          GLuint i;
  2565.          for (i = 0; i < n; i++) {
  2566.             GLuint s = d[i] & 0xff000000;
  2567.             GLuint z = (GLuint) (src[i] * scale);
  2568.             assert(z <= 0xffffff);
  2569.             d[i] = s | z;
  2570.          }
  2571.       }
  2572.       break;
  2573.    case MESA_FORMAT_Z16:
  2574.       {
  2575.          GLushort *d = ((GLushort *) dst);
  2576.          const GLfloat scale = (GLfloat) 0xffff;
  2577.          GLuint i;
  2578.          for (i = 0; i < n; i++) {
  2579.             d[i] = (GLushort) (src[i] * scale);
  2580.          }
  2581.       }
  2582.       break;
  2583.    case MESA_FORMAT_Z32:
  2584.       {
  2585.          GLuint *d = ((GLuint *) dst);
  2586.          const GLdouble scale = (GLdouble) 0xffffffff;
  2587.          GLuint i;
  2588.          for (i = 0; i < n; i++) {
  2589.             d[i] = (GLuint) (src[i] * scale);
  2590.          }
  2591.       }
  2592.       break;
  2593.    case MESA_FORMAT_Z32_FLOAT:
  2594.       memcpy(dst, src, n * sizeof(GLfloat));
  2595.       break;
  2596.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2597.       {
  2598.          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  2599.          GLuint i;
  2600.          for (i = 0; i < n; i++) {
  2601.             d[i].z = src[i];
  2602.          }
  2603.       }
  2604.       break;
  2605.    default:
  2606.       _mesa_problem(NULL, "unexpected format in _mesa_pack_float_z_row()");
  2607.    }
  2608. }
  2609.  
  2610.  
  2611. /**
  2612.  * The incoming Z values are always in the range [0, 0xffffffff].
  2613.  */
  2614. void
  2615. _mesa_pack_uint_z_row(gl_format format, GLuint n,
  2616.                       const GLuint *src, void *dst)
  2617. {
  2618.    switch (format) {
  2619.    case MESA_FORMAT_Z24_S8:
  2620.    case MESA_FORMAT_Z24_X8:
  2621.       {
  2622.          /* don't disturb the stencil values */
  2623.          GLuint *d = ((GLuint *) dst);
  2624.          GLuint i;
  2625.          for (i = 0; i < n; i++) {
  2626.             GLuint s = d[i] & 0xff;
  2627.             GLuint z = src[i] & 0xffffff00;
  2628.             d[i] = z | s;
  2629.          }
  2630.       }
  2631.       break;
  2632.    case MESA_FORMAT_S8_Z24:
  2633.    case MESA_FORMAT_X8_Z24:
  2634.       {
  2635.          /* don't disturb the stencil values */
  2636.          GLuint *d = ((GLuint *) dst);
  2637.          GLuint i;
  2638.          for (i = 0; i < n; i++) {
  2639.             GLuint s = d[i] & 0xff000000;
  2640.             GLuint z = src[i] >> 8;
  2641.             d[i] = s | z;
  2642.          }
  2643.       }
  2644.       break;
  2645.    case MESA_FORMAT_Z16:
  2646.       {
  2647.          GLushort *d = ((GLushort *) dst);
  2648.          GLuint i;
  2649.          for (i = 0; i < n; i++) {
  2650.             d[i] = src[i] >> 16;
  2651.          }
  2652.       }
  2653.       break;
  2654.    case MESA_FORMAT_Z32:
  2655.       memcpy(dst, src, n * sizeof(GLfloat));
  2656.       break;
  2657.    case MESA_FORMAT_Z32_FLOAT:
  2658.       {
  2659.          GLuint *d = ((GLuint *) dst);
  2660.          const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
  2661.          GLuint i;
  2662.          for (i = 0; i < n; i++) {
  2663.             d[i] = (GLuint) (src[i] * scale);
  2664.             assert(d[i] >= 0.0f);
  2665.             assert(d[i] <= 1.0f);
  2666.          }
  2667.       }
  2668.       break;
  2669.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2670.       {
  2671.          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  2672.          const GLdouble scale = 1.0 / (GLdouble) 0xffffffff;
  2673.          GLuint i;
  2674.          for (i = 0; i < n; i++) {
  2675.             d[i].z = (GLfloat) (src[i] * scale);
  2676.             assert(d[i].z >= 0.0f);
  2677.             assert(d[i].z <= 1.0f);
  2678.          }
  2679.       }
  2680.       break;
  2681.    default:
  2682.       _mesa_problem(NULL, "unexpected format in _mesa_pack_uint_z_row()");
  2683.    }
  2684. }
  2685.  
  2686.  
  2687. void
  2688. _mesa_pack_ubyte_stencil_row(gl_format format, GLuint n,
  2689.                              const GLubyte *src, void *dst)
  2690. {
  2691.    switch (format) {
  2692.    case MESA_FORMAT_Z24_S8:
  2693.       {
  2694.          /* don't disturb the Z values */
  2695.          GLuint *d = ((GLuint *) dst);
  2696.          GLuint i;
  2697.          for (i = 0; i < n; i++) {
  2698.             GLuint s = src[i];
  2699.             GLuint z = d[i] & 0xffffff00;
  2700.             d[i] = z | s;
  2701.          }
  2702.       }
  2703.       break;
  2704.    case MESA_FORMAT_S8_Z24:
  2705.       {
  2706.          /* don't disturb the Z values */
  2707.          GLuint *d = ((GLuint *) dst);
  2708.          GLuint i;
  2709.          for (i = 0; i < n; i++) {
  2710.             GLuint s = src[i] << 24;
  2711.             GLuint z = d[i] & 0xffffff;
  2712.             d[i] = s | z;
  2713.          }
  2714.       }
  2715.       break;
  2716.    case MESA_FORMAT_S8:
  2717.       memcpy(dst, src, n * sizeof(GLubyte));
  2718.       break;
  2719.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2720.       {
  2721.          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  2722.          GLuint i;
  2723.          for (i = 0; i < n; i++) {
  2724.             d[i].x24s8 = src[i];
  2725.          }
  2726.       }
  2727.       break;
  2728.    default:
  2729.       _mesa_problem(NULL, "unexpected format in _mesa_pack_ubyte_stencil_row()");
  2730.    }
  2731. }
  2732.  
  2733.  
  2734. /**
  2735.  * Incoming Z/stencil values are always in uint_24_8 format.
  2736.  */
  2737. void
  2738. _mesa_pack_uint_24_8_depth_stencil_row(gl_format format, GLuint n,
  2739.                                        const GLuint *src, void *dst)
  2740. {
  2741.    switch (format) {
  2742.    case MESA_FORMAT_Z24_S8:
  2743.       memcpy(dst, src, n * sizeof(GLuint));
  2744.       break;
  2745.    case MESA_FORMAT_S8_Z24:
  2746.       {
  2747.          GLuint *d = ((GLuint *) dst);
  2748.          GLuint i;
  2749.          for (i = 0; i < n; i++) {
  2750.             GLuint s = src[i] << 24;
  2751.             GLuint z = src[i] >> 8;
  2752.             d[i] = s | z;
  2753.          }
  2754.       }
  2755.       break;
  2756.    case MESA_FORMAT_Z32_FLOAT_X24S8:
  2757.       {
  2758.          const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
  2759.          struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  2760.          GLuint i;
  2761.          for (i = 0; i < n; i++) {
  2762.             GLfloat z = (GLfloat) ((src[i] >> 8) * scale);
  2763.             d[i].z = z;
  2764.             d[i].x24s8 = src[i];
  2765.          }
  2766.       }
  2767.       break;
  2768.    default:
  2769.       _mesa_problem(NULL, "bad format %s in _mesa_pack_ubyte_s_row",
  2770.                     _mesa_get_format_name(format));
  2771.       return;
  2772.    }
  2773. }
  2774.  
  2775.  
  2776.  
  2777. /**
  2778.  * Convert a boolean color mask to a packed color where each channel of
  2779.  * the packed value at dst will be 0 or ~0 depending on the colorMask.
  2780.  */
  2781. void
  2782. _mesa_pack_colormask(gl_format format, const GLubyte colorMask[4], void *dst)
  2783. {
  2784.    GLfloat maskColor[4];
  2785.  
  2786.    switch (_mesa_get_format_datatype(format)) {
  2787.    case GL_UNSIGNED_NORMALIZED:
  2788.       /* simple: 1.0 will convert to ~0 in the right bit positions */
  2789.       maskColor[0] = colorMask[0] ? 1.0f : 0.0f;
  2790.       maskColor[1] = colorMask[1] ? 1.0f : 0.0f;
  2791.       maskColor[2] = colorMask[2] ? 1.0f : 0.0f;
  2792.       maskColor[3] = colorMask[3] ? 1.0f : 0.0f;
  2793.       _mesa_pack_float_rgba_row(format, 1,
  2794.                                 (const GLfloat (*)[4]) maskColor, dst);
  2795.       break;
  2796.    case GL_SIGNED_NORMALIZED:
  2797.    case GL_FLOAT:
  2798.       /* These formats are harder because it's hard to know the floating
  2799.        * point values that will convert to ~0 for each color channel's bits.
  2800.        * This solution just generates a non-zero value for each color channel
  2801.        * then fixes up the non-zero values to be ~0.
  2802.        * Note: we'll need to add special case code if we ever have to deal
  2803.        * with formats with unequal color channel sizes, like R11_G11_B10.
  2804.        * We issue a warning below for channel sizes other than 8,16,32.
  2805.        */
  2806.       {
  2807.          GLuint bits = _mesa_get_format_max_bits(format); /* bits per chan */
  2808.          GLuint bytes = _mesa_get_format_bytes(format);
  2809.          GLuint i;
  2810.  
  2811.          /* this should put non-zero values into the channels of dst */
  2812.          maskColor[0] = colorMask[0] ? -1.0f : 0.0f;
  2813.          maskColor[1] = colorMask[1] ? -1.0f : 0.0f;
  2814.          maskColor[2] = colorMask[2] ? -1.0f : 0.0f;
  2815.          maskColor[3] = colorMask[3] ? -1.0f : 0.0f;
  2816.          _mesa_pack_float_rgba_row(format, 1,
  2817.                                    (const GLfloat (*)[4]) maskColor, dst);
  2818.  
  2819.          /* fix-up the dst channels by converting non-zero values to ~0 */
  2820.          if (bits == 8) {
  2821.             GLubyte *d = (GLubyte *) dst;
  2822.             for (i = 0; i < bytes; i++) {
  2823.                d[i] = d[i] ? 0xff : 0x0;
  2824.             }
  2825.          }
  2826.          else if (bits == 16) {
  2827.             GLushort *d = (GLushort *) dst;
  2828.             for (i = 0; i < bytes / 2; i++) {
  2829.                d[i] = d[i] ? 0xffff : 0x0;
  2830.             }
  2831.          }
  2832.          else if (bits == 32) {
  2833.             GLuint *d = (GLuint *) dst;
  2834.             for (i = 0; i < bytes / 4; i++) {
  2835.                d[i] = d[i] ? 0xffffffffU : 0x0;
  2836.             }
  2837.          }
  2838.          else {
  2839.             _mesa_problem(NULL, "unexpected size in _mesa_pack_colormask()");
  2840.             return;
  2841.          }
  2842.       }
  2843.       break;
  2844.    default:
  2845.       _mesa_problem(NULL, "unexpected format data type in gen_color_mask()");
  2846.       return;
  2847.    }
  2848. }
  2849.