Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. #!/usr/bin/env python
  2.  
  3. from mako.template import Template
  4. from sys import argv
  5.  
  6. string = """/*
  7. * Mesa 3-D graphics library
  8. *
  9. * Copyright (c) 2011 VMware, Inc.
  10. * Copyright (c) 2014 Intel Corporation.
  11. *
  12. * Permission is hereby granted, free of charge, to any person obtaining a
  13. * copy of this software and associated documentation files (the "Software"),
  14. * to deal in the Software without restriction, including without limitation
  15. * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  16. * and/or sell copies of the Software, and to permit persons to whom the
  17. * Software is furnished to do so, subject to the following conditions:
  18. *
  19. * The above copyright notice and this permission notice shall be included
  20. * in all copies or substantial portions of the Software.
  21. *
  22. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23. * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  25. * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  26. * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  27. * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  28. * OTHER DEALINGS IN THE SOFTWARE.
  29. */
  30.  
  31.  
  32. /**
  33. * Color, depth, stencil packing functions.
  34. * Used to pack basic color, depth and stencil formats to specific
  35. * hardware formats.
  36. *
  37. * There are both per-pixel and per-row packing functions:
  38. * - The former will be used by swrast to write values to the color, depth,
  39. *   stencil buffers when drawing points, lines and masked spans.
  40. * - The later will be used for image-oriented functions like glDrawPixels,
  41. *   glAccum, and glTexImage.
  42. */
  43.  
  44. #include <stdint.h>
  45.  
  46. #include "format_unpack.h"
  47. #include "format_utils.h"
  48. #include "macros.h"
  49. #include "../../gallium/auxiliary/util/u_format_rgb9e5.h"
  50. #include "../../gallium/auxiliary/util/u_format_r11g11b10f.h"
  51. #include "util/format_srgb.h"
  52.  
  53. #define UNPACK(SRC, OFFSET, BITS) (((SRC) >> (OFFSET)) & MAX_UINT(BITS))
  54.  
  55. <%
  56. import format_parser as parser
  57.  
  58. formats = parser.parse(argv[1])
  59.  
  60. rgb_formats = []
  61. for f in formats:
  62.   if f.name == 'MESA_FORMAT_NONE':
  63.      continue
  64.   if f.colorspace not in ('rgb', 'srgb'):
  65.      continue
  66.  
  67.   rgb_formats.append(f)
  68. %>
  69.  
  70. /* float unpacking functions */
  71.  
  72. %for f in rgb_formats:
  73.   %if f.name in ('MESA_FORMAT_R9G9B9E5_FLOAT', 'MESA_FORMAT_R11G11B10_FLOAT'):
  74.      <% continue %>
  75.   %elif f.is_int() and not f.is_normalized():
  76.      <% continue %>
  77.   %elif f.is_compressed():
  78.      <% continue %>
  79.   %endif
  80.  
  81. static inline void
  82. unpack_float_${f.short_name()}(const void *void_src, GLfloat dst[4])
  83. {
  84.   ${f.datatype()} *src = (${f.datatype()} *)void_src;
  85.   %if f.layout == parser.PACKED:
  86.      %for c in f.channels:
  87.         %if c.type != 'x':
  88.            ${c.datatype()} ${c.name} = UNPACK(*src, ${c.shift}, ${c.size});
  89.         %endif
  90.      %endfor
  91.   %elif f.layout == parser.ARRAY:
  92.      %for (i, c) in enumerate(f.channels):
  93.         %if c.type != 'x':
  94.            ${c.datatype()} ${c.name} = src[${i}];
  95.         %endif
  96.      %endfor
  97.   %else:
  98.      <% assert False %>
  99.   %endif
  100.  
  101.   %for i in range(4):
  102.      <% s = f.swizzle[i] %>
  103.      %if 0 <= s and s <= parser.Swizzle.SWIZZLE_W:
  104.         <% c = f.channels[s] %>
  105.         %if c.type == parser.UNSIGNED:
  106.            %if f.colorspace == 'srgb' and c.name in 'rgb':
  107.               <% assert c.size == 8 %>
  108.               dst[${i}] = util_format_srgb_8unorm_to_linear_float(${c.name});
  109.            %else:
  110.               dst[${i}] = _mesa_unorm_to_float(${c.name}, ${c.size});
  111.            %endif
  112.         %elif c.type == parser.SIGNED:
  113.            dst[${i}] = _mesa_snorm_to_float(${c.name}, ${c.size});
  114.         %elif c.type == parser.FLOAT:
  115.            %if c.size == 32:
  116.               dst[${i}] = ${c.name};
  117.            %elif c.size == 16:
  118.               dst[${i}] = _mesa_half_to_float(${c.name});
  119.            %else:
  120.               <% assert False %>
  121.            %endif
  122.         %else:
  123.            <% assert False %>
  124.         %endif
  125.      %elif s == parser.Swizzle.SWIZZLE_ZERO:
  126.         dst[${i}] = 0.0f;
  127.      %elif s == parser.Swizzle.SWIZZLE_ONE:
  128.         dst[${i}] = 1.0f;
  129.      %else:
  130.         <% assert False %>
  131.      %endif
  132.   %endfor
  133. }
  134. %endfor
  135.  
  136. static void
  137. unpack_float_r9g9b9e5_float(const void *src, GLfloat dst[4])
  138. {
  139.   rgb9e5_to_float3(*(const GLuint *)src, dst);
  140.   dst[3] = 1.0f;
  141. }
  142.  
  143. static void
  144. unpack_float_r11g11b10_float(const void *src, GLfloat dst[4])
  145. {
  146.   r11g11b10f_to_float3(*(const GLuint *)src, dst);
  147.   dst[3] = 1.0f;
  148. }
  149.  
  150. static void
  151. unpack_float_ycbcr(const void *src, GLfloat dst[][4], GLuint n)
  152. {
  153.   GLuint i;
  154.   for (i = 0; i < n; i++) {
  155.      const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
  156.      const GLushort *src1 = src0 + 1;         /* odd */
  157.      const GLubyte y0 = (*src0 >> 8) & 0xff;  /* luminance */
  158.      const GLubyte cb = *src0 & 0xff;         /* chroma U */
  159.      const GLubyte y1 = (*src1 >> 8) & 0xff;  /* luminance */
  160.      const GLubyte cr = *src1 & 0xff;         /* chroma V */
  161.      const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
  162.      GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
  163.      GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
  164.      GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
  165.      r *= (1.0F / 255.0F);
  166.      g *= (1.0F / 255.0F);
  167.      b *= (1.0F / 255.0F);
  168.      dst[i][0] = CLAMP(r, 0.0F, 1.0F);
  169.      dst[i][1] = CLAMP(g, 0.0F, 1.0F);
  170.      dst[i][2] = CLAMP(b, 0.0F, 1.0F);
  171.      dst[i][3] = 1.0F;
  172.   }
  173. }
  174.  
  175. static void
  176. unpack_float_ycbcr_rev(const void *src, GLfloat dst[][4], GLuint n)
  177. {
  178.   GLuint i;
  179.   for (i = 0; i < n; i++) {
  180.      const GLushort *src0 = ((const GLushort *) src) + i * 2; /* even */
  181.      const GLushort *src1 = src0 + 1;         /* odd */
  182.      const GLubyte y0 = *src0 & 0xff;         /* luminance */
  183.      const GLubyte cr = (*src0 >> 8) & 0xff;  /* chroma V */
  184.      const GLubyte y1 = *src1 & 0xff;         /* luminance */
  185.      const GLubyte cb = (*src1 >> 8) & 0xff;  /* chroma U */
  186.      const GLubyte y = (i & 1) ? y1 : y0;     /* choose even/odd luminance */
  187.      GLfloat r = 1.164F * (y - 16) + 1.596F * (cr - 128);
  188.      GLfloat g = 1.164F * (y - 16) - 0.813F * (cr - 128) - 0.391F * (cb - 128);
  189.      GLfloat b = 1.164F * (y - 16) + 2.018F * (cb - 128);
  190.      r *= (1.0F / 255.0F);
  191.      g *= (1.0F / 255.0F);
  192.      b *= (1.0F / 255.0F);
  193.      dst[i][0] = CLAMP(r, 0.0F, 1.0F);
  194.      dst[i][1] = CLAMP(g, 0.0F, 1.0F);
  195.      dst[i][2] = CLAMP(b, 0.0F, 1.0F);
  196.      dst[i][3] = 1.0F;
  197.   }
  198. }
  199.  
  200. /* ubyte packing functions */
  201.  
  202. %for f in rgb_formats:
  203.   %if not f.is_normalized():
  204.      <% continue %>
  205.   %endif
  206.  
  207. static inline void
  208. unpack_ubyte_${f.short_name()}(const void *void_src, GLubyte dst[4])
  209. {
  210.   ${f.datatype()} *src = (${f.datatype()} *)void_src;
  211.   %if f.layout == parser.PACKED:
  212.      %for c in f.channels:
  213.         %if c.type != 'x':
  214.            ${c.datatype()} ${c.name} = UNPACK(*src, ${c.shift}, ${c.size});
  215.         %endif
  216.      %endfor
  217.   %elif f.layout == parser.ARRAY:
  218.      %for (i, c) in enumerate(f.channels):
  219.         %if c.type != 'x':
  220.            ${c.datatype()} ${c.name} = src[${i}];
  221.         %endif
  222.      %endfor
  223.   %else:
  224.      <% assert False %>
  225.   %endif
  226.  
  227.   %for i in range(4):
  228.      <% s = f.swizzle[i] %>
  229.      %if 0 <= s and s <= parser.Swizzle.SWIZZLE_W:
  230.         <% c = f.channels[s] %>
  231.         %if c.type == parser.UNSIGNED:
  232.            %if f.colorspace == 'srgb' and c.name in 'rgb':
  233.               <% assert c.size == 8 %>
  234.               dst[${i}] = util_format_srgb_to_linear_8unorm(${c.name});
  235.            %else:
  236.               dst[${i}] = _mesa_unorm_to_unorm(${c.name}, ${c.size}, 8);
  237.            %endif
  238.         %elif c.type == parser.SIGNED:
  239.            dst[${i}] = _mesa_snorm_to_unorm(${c.name}, ${c.size}, 8);
  240.         %elif c.type == parser.FLOAT:
  241.            %if c.size == 32:
  242.               dst[${i}] = _mesa_float_to_unorm(${c.name}, 8);
  243.            %elif c.size == 16:
  244.               dst[${i}] = _mesa_half_to_unorm(${c.name}, 8);
  245.            %else:
  246.               <% assert False %>
  247.            %endif
  248.         %else:
  249.            <% assert False %>
  250.         %endif
  251.      %elif s == parser.Swizzle.SWIZZLE_ZERO:
  252.         dst[${i}] = 0;
  253.      %elif s == parser.Swizzle.SWIZZLE_ONE:
  254.         dst[${i}] = 255;
  255.      %else:
  256.         <% assert False %>
  257.      %endif
  258.   %endfor
  259. }
  260. %endfor
  261.  
  262. /* integer packing functions */
  263.  
  264. %for f in rgb_formats:
  265.   %if not f.is_int():
  266.      <% continue %>
  267.   %elif f.is_normalized():
  268.      <% continue %>
  269.   %endif
  270.  
  271. static inline void
  272. unpack_int_${f.short_name()}(const void *void_src, GLuint dst[4])
  273. {
  274.   ${f.datatype()} *src = (${f.datatype()} *)void_src;
  275.   %if f.layout == parser.PACKED:
  276.      %for c in f.channels:
  277.         %if c.type != 'x':
  278.            ${c.datatype()} ${c.name} = UNPACK(*src, ${c.shift}, ${c.size});
  279.         %endif
  280.      %endfor
  281.   %elif f.layout == parser.ARRAY:
  282.      %for (i, c) in enumerate(f.channels):
  283.         %if c.type != 'x':
  284.            ${c.datatype()} ${c.name} = src[${i}];
  285.         %endif
  286.      %endfor
  287.   %else:
  288.      <% assert False %>
  289.   %endif
  290.  
  291.   %for i in range(4):
  292.      <% s = f.swizzle[i] %>
  293.      %if 0 <= s and s <= parser.Swizzle.SWIZZLE_W:
  294.         dst[${i}] = ${f.channels[s].name};
  295.      %elif s == parser.Swizzle.SWIZZLE_ZERO:
  296.         dst[${i}] = 0;
  297.      %elif s == parser.Swizzle.SWIZZLE_ONE:
  298.         dst[${i}] = 1;
  299.      %else:
  300.         <% assert False %>
  301.      %endif
  302.   %endfor
  303. }
  304. %endfor
  305.  
  306.  
  307. void
  308. _mesa_unpack_rgba_row(mesa_format format, GLuint n,
  309.                      const void *src, GLfloat dst[][4])
  310. {
  311.   GLubyte *s = (GLubyte *)src;
  312.   GLuint i;
  313.  
  314.   switch (format) {
  315. %for f in rgb_formats:
  316.   %if f.is_compressed():
  317.      <% continue %>
  318.   %elif f.is_int() and not f.is_normalized():
  319.      <% continue %>
  320.   %endif
  321.   case ${f.name}:
  322.      for (i = 0; i < n; ++i) {
  323.         unpack_float_${f.short_name()}(s, dst[i]);
  324.         s += ${f.block_size() / 8};
  325.      }
  326.      break;
  327. %endfor
  328.   case MESA_FORMAT_YCBCR:
  329.      unpack_float_ycbcr(src, dst, n);
  330.      break;
  331.   case MESA_FORMAT_YCBCR_REV:
  332.      unpack_float_ycbcr_rev(src, dst, n);
  333.      break;
  334.   default:
  335.      _mesa_problem(NULL, "%s: bad format %s", __func__,
  336.                    _mesa_get_format_name(format));
  337.      return;
  338.   }
  339. }
  340.  
  341. void
  342. _mesa_unpack_ubyte_rgba_row(mesa_format format, GLuint n,
  343.                            const void *src, GLubyte dst[][4])
  344. {
  345.   GLubyte *s = (GLubyte *)src;
  346.   GLuint i;
  347.  
  348.   switch (format) {
  349. %for f in rgb_formats:
  350.   %if not f.is_normalized():
  351.      <% continue %>
  352.   %endif
  353.  
  354.   case ${f.name}:
  355.      for (i = 0; i < n; ++i) {
  356.         unpack_ubyte_${f.short_name()}(s, dst[i]);
  357.         s += ${f.block_size() / 8};
  358.      }
  359.      break;
  360. %endfor
  361.   default:
  362.      /* get float values, convert to ubyte */
  363.      {
  364.         GLfloat *tmp = malloc(n * 4 * sizeof(GLfloat));
  365.         if (tmp) {
  366.            GLuint i;
  367.            _mesa_unpack_rgba_row(format, n, src, (GLfloat (*)[4]) tmp);
  368.            for (i = 0; i < n; i++) {
  369.               dst[i][0] = _mesa_float_to_unorm(tmp[i*4+0], 8);
  370.               dst[i][1] = _mesa_float_to_unorm(tmp[i*4+1], 8);
  371.               dst[i][2] = _mesa_float_to_unorm(tmp[i*4+2], 8);
  372.               dst[i][3] = _mesa_float_to_unorm(tmp[i*4+3], 8);
  373.            }
  374.            free(tmp);
  375.         }
  376.      }
  377.      break;
  378.   }
  379. }
  380.  
  381. void
  382. _mesa_unpack_uint_rgba_row(mesa_format format, GLuint n,
  383.                           const void *src, GLuint dst[][4])
  384. {
  385.   GLubyte *s = (GLubyte *)src;
  386.   GLuint i;
  387.  
  388.   switch (format) {
  389. %for f in rgb_formats:
  390.   %if not f.is_int():
  391.      <% continue %>
  392.   %elif f.is_normalized():
  393.      <% continue %>
  394.   %endif
  395.  
  396.   case ${f.name}:
  397.      for (i = 0; i < n; ++i) {
  398.         unpack_int_${f.short_name()}(s, dst[i]);
  399.         s += ${f.block_size() / 8};
  400.      }
  401.      break;
  402. %endfor
  403.   default:
  404.      _mesa_problem(NULL, "%s: bad format %s", __func__,
  405.                    _mesa_get_format_name(format));
  406.      return;
  407.   }
  408. }
  409.  
  410. /**
  411. * Unpack a 2D rect of pixels returning float RGBA colors.
  412. * \param format  the source image format
  413. * \param src  start address of the source image
  414. * \param srcRowStride  source image row stride in bytes
  415. * \param dst  start address of the dest image
  416. * \param dstRowStride  dest image row stride in bytes
  417. * \param x  source image start X pos
  418. * \param y  source image start Y pos
  419. * \param width  width of rect region to convert
  420. * \param height  height of rect region to convert
  421. */
  422. void
  423. _mesa_unpack_rgba_block(mesa_format format,
  424.                        const void *src, GLint srcRowStride,
  425.                        GLfloat dst[][4], GLint dstRowStride,
  426.                        GLuint x, GLuint y, GLuint width, GLuint height)
  427. {
  428.   const GLuint srcPixStride = _mesa_get_format_bytes(format);
  429.   const GLuint dstPixStride = 4 * sizeof(GLfloat);
  430.   const GLubyte *srcRow;
  431.   GLubyte *dstRow;
  432.   GLuint i;
  433.  
  434.   /* XXX needs to be fixed for compressed formats */
  435.  
  436.   srcRow = ((const GLubyte *) src) + srcRowStride * y + srcPixStride * x;
  437.   dstRow = ((GLubyte *) dst) + dstRowStride * y + dstPixStride * x;
  438.  
  439.   for (i = 0; i < height; i++) {
  440.      _mesa_unpack_rgba_row(format, width, srcRow, (GLfloat (*)[4]) dstRow);
  441.  
  442.      dstRow += dstRowStride;
  443.      srcRow += srcRowStride;
  444.   }
  445. }
  446.  
  447. /** Helper struct for MESA_FORMAT_Z32_FLOAT_S8X24_UINT */
  448. struct z32f_x24s8
  449. {
  450.   float z;
  451.   uint32_t x24s8;
  452. };
  453.  
  454. typedef void (*unpack_float_z_func)(GLuint n, const void *src, GLfloat *dst);
  455.  
  456. static void
  457. unpack_float_z_X8_UINT_Z24_UNORM(GLuint n, const void *src, GLfloat *dst)
  458. {
  459.   /* only return Z, not stencil data */
  460.   const GLuint *s = ((const GLuint *) src);
  461.   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
  462.   GLuint i;
  463.   for (i = 0; i < n; i++) {
  464.      dst[i] = (GLfloat) ((s[i] >> 8) * scale);
  465.      assert(dst[i] >= 0.0F);
  466.      assert(dst[i] <= 1.0F);
  467.   }
  468. }
  469.  
  470. static void
  471. unpack_float_z_Z24_UNORM_X8_UINT(GLuint n, const void *src, GLfloat *dst)
  472. {
  473.   /* only return Z, not stencil data */
  474.   const GLuint *s = ((const GLuint *) src);
  475.   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
  476.   GLuint i;
  477.   for (i = 0; i < n; i++) {
  478.      dst[i] = (GLfloat) ((s[i] & 0x00ffffff) * scale);
  479.      assert(dst[i] >= 0.0F);
  480.      assert(dst[i] <= 1.0F);
  481.   }
  482. }
  483.  
  484. static void
  485. unpack_float_Z_UNORM16(GLuint n, const void *src, GLfloat *dst)
  486. {
  487.   const GLushort *s = ((const GLushort *) src);
  488.   GLuint i;
  489.   for (i = 0; i < n; i++) {
  490.      dst[i] = s[i] * (1.0F / 65535.0F);
  491.   }
  492. }
  493.  
  494. static void
  495. unpack_float_Z_UNORM32(GLuint n, const void *src, GLfloat *dst)
  496. {
  497.   const GLuint *s = ((const GLuint *) src);
  498.   GLuint i;
  499.   for (i = 0; i < n; i++) {
  500.      dst[i] = s[i] * (1.0F / 0xffffffff);
  501.   }
  502. }
  503.  
  504. static void
  505. unpack_float_Z_FLOAT32(GLuint n, const void *src, GLfloat *dst)
  506. {
  507.   memcpy(dst, src, n * sizeof(float));
  508. }
  509.  
  510. static void
  511. unpack_float_z_Z32X24S8(GLuint n, const void *src, GLfloat *dst)
  512. {
  513.   const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
  514.   GLuint i;
  515.   for (i = 0; i < n; i++) {
  516.      dst[i] = s[i].z;
  517.   }
  518. }
  519.  
  520.  
  521.  
  522. /**
  523. * Unpack Z values.
  524. * The returned values will always be in the range [0.0, 1.0].
  525. */
  526. void
  527. _mesa_unpack_float_z_row(mesa_format format, GLuint n,
  528.                         const void *src, GLfloat *dst)
  529. {
  530.   unpack_float_z_func unpack;
  531.  
  532.   switch (format) {
  533.   case MESA_FORMAT_S8_UINT_Z24_UNORM:
  534.   case MESA_FORMAT_X8_UINT_Z24_UNORM:
  535.      unpack = unpack_float_z_X8_UINT_Z24_UNORM;
  536.      break;
  537.   case MESA_FORMAT_Z24_UNORM_S8_UINT:
  538.   case MESA_FORMAT_Z24_UNORM_X8_UINT:
  539.      unpack = unpack_float_z_Z24_UNORM_X8_UINT;
  540.      break;
  541.   case MESA_FORMAT_Z_UNORM16:
  542.      unpack = unpack_float_Z_UNORM16;
  543.      break;
  544.   case MESA_FORMAT_Z_UNORM32:
  545.      unpack = unpack_float_Z_UNORM32;
  546.      break;
  547.   case MESA_FORMAT_Z_FLOAT32:
  548.      unpack = unpack_float_Z_FLOAT32;
  549.      break;
  550.   case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
  551.      unpack = unpack_float_z_Z32X24S8;
  552.      break;
  553.   default:
  554.      _mesa_problem(NULL, "bad format %s in _mesa_unpack_float_z_row",
  555.                    _mesa_get_format_name(format));
  556.      return;
  557.   }
  558.  
  559.   unpack(n, src, dst);
  560. }
  561.  
  562.  
  563.  
  564. typedef void (*unpack_uint_z_func)(const void *src, GLuint *dst, GLuint n);
  565.  
  566. static void
  567. unpack_uint_z_X8_UINT_Z24_UNORM(const void *src, GLuint *dst, GLuint n)
  568. {
  569.   /* only return Z, not stencil data */
  570.   const GLuint *s = ((const GLuint *) src);
  571.   GLuint i;
  572.   for (i = 0; i < n; i++) {
  573.      dst[i] = (s[i] & 0xffffff00) | (s[i] >> 24);
  574.   }
  575. }
  576.  
  577. static void
  578. unpack_uint_z_Z24_UNORM_X8_UINT(const void *src, GLuint *dst, GLuint n)
  579. {
  580.   /* only return Z, not stencil data */
  581.   const GLuint *s = ((const GLuint *) src);
  582.   GLuint i;
  583.   for (i = 0; i < n; i++) {
  584.      dst[i] = (s[i] << 8) | ((s[i] >> 16) & 0xff);
  585.   }
  586. }
  587.  
  588. static void
  589. unpack_uint_Z_UNORM16(const void *src, GLuint *dst, GLuint n)
  590. {
  591.   const GLushort *s = ((const GLushort *)src);
  592.   GLuint i;
  593.   for (i = 0; i < n; i++) {
  594.      dst[i] = (s[i] << 16) | s[i];
  595.   }
  596. }
  597.  
  598. static void
  599. unpack_uint_Z_UNORM32(const void *src, GLuint *dst, GLuint n)
  600. {
  601.   memcpy(dst, src, n * sizeof(GLuint));
  602. }
  603.  
  604. static void
  605. unpack_uint_Z_FLOAT32(const void *src, GLuint *dst, GLuint n)
  606. {
  607.   const float *s = (const float *)src;
  608.   GLuint i;
  609.   for (i = 0; i < n; i++) {
  610.      dst[i] = FLOAT_TO_UINT(CLAMP(s[i], 0.0F, 1.0F));
  611.   }
  612. }
  613.  
  614. static void
  615. unpack_uint_Z_FLOAT32_X24S8(const void *src, GLuint *dst, GLuint n)
  616. {
  617.   const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
  618.   GLuint i;
  619.  
  620.   for (i = 0; i < n; i++) {
  621.      dst[i] = FLOAT_TO_UINT(CLAMP(s[i].z, 0.0F, 1.0F));
  622.   }
  623. }
  624.  
  625.  
  626. /**
  627. * Unpack Z values.
  628. * The returned values will always be in the range [0, 0xffffffff].
  629. */
  630. void
  631. _mesa_unpack_uint_z_row(mesa_format format, GLuint n,
  632.                        const void *src, GLuint *dst)
  633. {
  634.   unpack_uint_z_func unpack;
  635.   const GLubyte *srcPtr = (GLubyte *) src;
  636.  
  637.   switch (format) {
  638.   case MESA_FORMAT_S8_UINT_Z24_UNORM:
  639.   case MESA_FORMAT_X8_UINT_Z24_UNORM:
  640.      unpack = unpack_uint_z_X8_UINT_Z24_UNORM;
  641.      break;
  642.   case MESA_FORMAT_Z24_UNORM_S8_UINT:
  643.   case MESA_FORMAT_Z24_UNORM_X8_UINT:
  644.      unpack = unpack_uint_z_Z24_UNORM_X8_UINT;
  645.      break;
  646.   case MESA_FORMAT_Z_UNORM16:
  647.      unpack = unpack_uint_Z_UNORM16;
  648.      break;
  649.   case MESA_FORMAT_Z_UNORM32:
  650.      unpack = unpack_uint_Z_UNORM32;
  651.      break;
  652.   case MESA_FORMAT_Z_FLOAT32:
  653.      unpack = unpack_uint_Z_FLOAT32;
  654.      break;
  655.   case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
  656.      unpack = unpack_uint_Z_FLOAT32_X24S8;
  657.      break;
  658.   default:
  659.      _mesa_problem(NULL, "bad format %s in _mesa_unpack_uint_z_row",
  660.                    _mesa_get_format_name(format));
  661.      return;
  662.   }
  663.  
  664.   unpack(srcPtr, dst, n);
  665. }
  666.  
  667.  
  668. static void
  669. unpack_ubyte_s_S_UINT8(const void *src, GLubyte *dst, GLuint n)
  670. {
  671.   memcpy(dst, src, n);
  672. }
  673.  
  674. static void
  675. unpack_ubyte_s_S8_UINT_Z24_UNORM(const void *src, GLubyte *dst, GLuint n)
  676. {
  677.   GLuint i;
  678.   const GLuint *src32 = src;
  679.  
  680.   for (i = 0; i < n; i++)
  681.      dst[i] = src32[i] & 0xff;
  682. }
  683.  
  684. static void
  685. unpack_ubyte_s_Z24_UNORM_S8_UINT(const void *src, GLubyte *dst, GLuint n)
  686. {
  687.   GLuint i;
  688.   const GLuint *src32 = src;
  689.  
  690.   for (i = 0; i < n; i++)
  691.      dst[i] = src32[i] >> 24;
  692. }
  693.  
  694. static void
  695. unpack_ubyte_s_Z32_FLOAT_S8X24_UINT(const void *src, GLubyte *dst, GLuint n)
  696. {
  697.   GLuint i;
  698.   const struct z32f_x24s8 *s = (const struct z32f_x24s8 *) src;
  699.  
  700.   for (i = 0; i < n; i++)
  701.      dst[i] = s[i].x24s8 & 0xff;
  702. }
  703.  
  704. void
  705. _mesa_unpack_ubyte_stencil_row(mesa_format format, GLuint n,
  706.                                const void *src, GLubyte *dst)
  707. {
  708.   switch (format) {
  709.   case MESA_FORMAT_S_UINT8:
  710.      unpack_ubyte_s_S_UINT8(src, dst, n);
  711.      break;
  712.   case MESA_FORMAT_S8_UINT_Z24_UNORM:
  713.      unpack_ubyte_s_S8_UINT_Z24_UNORM(src, dst, n);
  714.      break;
  715.   case MESA_FORMAT_Z24_UNORM_S8_UINT:
  716.      unpack_ubyte_s_Z24_UNORM_S8_UINT(src, dst, n);
  717.      break;
  718.   case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
  719.      unpack_ubyte_s_Z32_FLOAT_S8X24_UINT(src, dst, n);
  720.      break;
  721.   default:
  722.      _mesa_problem(NULL, "bad format %s in _mesa_unpack_ubyte_s_row",
  723.                    _mesa_get_format_name(format));
  724.      return;
  725.   }
  726. }
  727.  
  728. static void
  729. unpack_uint_24_8_depth_stencil_Z24_UNORM_S8_UINT(const GLuint *src, GLuint *dst, GLuint n)
  730. {
  731.   GLuint i;
  732.  
  733.   for (i = 0; i < n; i++) {
  734.      GLuint val = src[i];
  735.      dst[i] = val >> 24 | val << 8;
  736.   }
  737. }
  738.  
  739. static void
  740. unpack_uint_24_8_depth_stencil_Z32_S8X24(const GLuint *src,
  741.                                         GLuint *dst, GLuint n)
  742. {
  743.   GLuint i;
  744.  
  745.   for (i = 0; i < n; i++) {
  746.      /* 8 bytes per pixel (float + uint32) */
  747.      GLfloat zf = ((GLfloat *) src)[i * 2 + 0];
  748.      GLuint z24 = (GLuint) (zf * (GLfloat) 0xffffff);
  749.      GLuint s = src[i * 2 + 1] & 0xff;
  750.      dst[i] = (z24 << 8) | s;
  751.   }
  752. }
  753.  
  754. static void
  755. unpack_uint_24_8_depth_stencil_S8_UINT_Z24_UNORM(const GLuint *src, GLuint *dst, GLuint n)
  756. {
  757.   memcpy(dst, src, n * 4);
  758. }
  759.  
  760. /**
  761. * Unpack depth/stencil returning as GL_UNSIGNED_INT_24_8.
  762. * \param format  the source data format
  763. */
  764. void
  765. _mesa_unpack_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
  766.                                          const void *src, GLuint *dst)
  767. {
  768.   switch (format) {
  769.   case MESA_FORMAT_S8_UINT_Z24_UNORM:
  770.      unpack_uint_24_8_depth_stencil_S8_UINT_Z24_UNORM(src, dst, n);
  771.      break;
  772.   case MESA_FORMAT_Z24_UNORM_S8_UINT:
  773.      unpack_uint_24_8_depth_stencil_Z24_UNORM_S8_UINT(src, dst, n);
  774.      break;
  775.   case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
  776.      unpack_uint_24_8_depth_stencil_Z32_S8X24(src, dst, n);
  777.      break;
  778.   default:
  779.      _mesa_problem(NULL,
  780.                    "bad format %s in _mesa_unpack_uint_24_8_depth_stencil_row",
  781.                    _mesa_get_format_name(format));
  782.      return;
  783.   }
  784. }
  785.  
  786. static void
  787. unpack_float_32_uint_24_8_Z24_UNORM_S8_UINT(const GLuint *src,
  788.                                            GLuint *dst, GLuint n)
  789. {
  790.   GLuint i;
  791.   struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  792.   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
  793.  
  794.   for (i = 0; i < n; i++) {
  795.      const GLuint z24 = src[i] & 0xffffff;
  796.      d[i].z = z24 * scale;
  797.      d[i].x24s8 = src[i] >> 24;
  798.      assert(d[i].z >= 0.0f);
  799.      assert(d[i].z <= 1.0f);
  800.   }
  801. }
  802.  
  803. static void
  804. unpack_float_32_uint_24_8_Z32_FLOAT_S8X24_UINT(const GLuint *src,
  805.                                               GLuint *dst, GLuint n)
  806. {
  807.   memcpy(dst, src, n * sizeof(struct z32f_x24s8));
  808. }
  809.  
  810. static void
  811. unpack_float_32_uint_24_8_S8_UINT_Z24_UNORM(const GLuint *src,
  812.                                            GLuint *dst, GLuint n)
  813. {
  814.   GLuint i;
  815.   struct z32f_x24s8 *d = (struct z32f_x24s8 *) dst;
  816.   const GLdouble scale = 1.0 / (GLdouble) 0xffffff;
  817.  
  818.   for (i = 0; i < n; i++) {
  819.      const GLuint z24 = src[i] >> 8;
  820.      d[i].z = z24 * scale;
  821.      d[i].x24s8 = src[i] & 0xff;
  822.      assert(d[i].z >= 0.0f);
  823.      assert(d[i].z <= 1.0f);
  824.   }
  825. }
  826.  
  827. /**
  828. * Unpack depth/stencil returning as GL_FLOAT_32_UNSIGNED_INT_24_8_REV.
  829. * \param format  the source data format
  830. *
  831. * In GL_FLOAT_32_UNSIGNED_INT_24_8_REV lower 4 bytes contain float
  832. * component and higher 4 bytes contain packed 24-bit and 8-bit
  833. * components.
  834. *
  835. *    31 30 29 28 ... 4 3 2 1 0    31 30 29 ... 9 8 7 6 5 ... 2 1 0
  836. *    +-------------------------+  +--------------------------------+
  837. *    |    Float Component      |  | Unused         | 8 bit stencil |
  838. *    +-------------------------+  +--------------------------------+
  839. *          lower 4 bytes                  higher 4 bytes
  840. */
  841. void
  842. _mesa_unpack_float_32_uint_24_8_depth_stencil_row(mesa_format format, GLuint n,
  843.                                                   const void *src, GLuint *dst)
  844. {
  845.   switch (format) {
  846.   case MESA_FORMAT_S8_UINT_Z24_UNORM:
  847.      unpack_float_32_uint_24_8_S8_UINT_Z24_UNORM(src, dst, n);
  848.      break;
  849.   case MESA_FORMAT_Z24_UNORM_S8_UINT:
  850.      unpack_float_32_uint_24_8_Z24_UNORM_S8_UINT(src, dst, n);
  851.      break;
  852.   case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
  853.      unpack_float_32_uint_24_8_Z32_FLOAT_S8X24_UINT(src, dst, n);
  854.      break;
  855.   default:
  856.      _mesa_problem(NULL,
  857.                    "bad format %s in _mesa_unpack_uint_24_8_depth_stencil_row",
  858.                    _mesa_get_format_name(format));
  859.      return;
  860.   }
  861. }
  862.  
  863. /**
  864. * Unpack depth/stencil
  865. * \param format  the source data format
  866. * \param type the destination data type
  867. */
  868. void
  869. _mesa_unpack_depth_stencil_row(mesa_format format, GLuint n,
  870.                                const void *src, GLenum type,
  871.                               GLuint *dst)
  872. {
  873.   assert(type == GL_UNSIGNED_INT_24_8 ||
  874.          type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV);
  875.  
  876.   switch (type) {
  877.   case GL_UNSIGNED_INT_24_8:
  878.      _mesa_unpack_uint_24_8_depth_stencil_row(format, n, src, dst);
  879.      break;
  880.   case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
  881.      _mesa_unpack_float_32_uint_24_8_depth_stencil_row(format, n, src, dst);
  882.      break;
  883.   default:
  884.      _mesa_problem(NULL,
  885.                    "bad type 0x%x in _mesa_unpack_depth_stencil_row",
  886.                    type);
  887.      return;
  888.   }
  889. }
  890. """
  891.  
  892. template = Template(string);
  893.  
  894. print template.render(argv = argv[0:])
  895.