Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  5.  * Copyright (C) 2009-2010  VMware, Inc.  All Rights Reserved.
  6.  *
  7.  * Permission is hereby granted, free of charge, to any person obtaining a
  8.  * copy of this software and associated documentation files (the "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice shall be included
  15.  * in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25.  
  26. /**
  27.  * \file pixeltransfer.c
  28.  * Pixel transfer operations (scale, bias, table lookups, etc)
  29.  */
  30.  
  31.  
  32. #include "glheader.h"
  33. #include "colormac.h"
  34. #include "pixeltransfer.h"
  35. #include "imports.h"
  36.  
  37.  
  38. /*
  39.  * Apply scale and bias factors to an array of RGBA pixels.
  40.  */
  41. void
  42. _mesa_scale_and_bias_rgba(GLuint n, GLfloat rgba[][4],
  43.                           GLfloat rScale, GLfloat gScale,
  44.                           GLfloat bScale, GLfloat aScale,
  45.                           GLfloat rBias, GLfloat gBias,
  46.                           GLfloat bBias, GLfloat aBias)
  47. {
  48.    if (rScale != 1.0 || rBias != 0.0) {
  49.       GLuint i;
  50.       for (i = 0; i < n; i++) {
  51.          rgba[i][RCOMP] = rgba[i][RCOMP] * rScale + rBias;
  52.       }
  53.    }
  54.    if (gScale != 1.0 || gBias != 0.0) {
  55.       GLuint i;
  56.       for (i = 0; i < n; i++) {
  57.          rgba[i][GCOMP] = rgba[i][GCOMP] * gScale + gBias;
  58.       }
  59.    }
  60.    if (bScale != 1.0 || bBias != 0.0) {
  61.       GLuint i;
  62.       for (i = 0; i < n; i++) {
  63.          rgba[i][BCOMP] = rgba[i][BCOMP] * bScale + bBias;
  64.       }
  65.    }
  66.    if (aScale != 1.0 || aBias != 0.0) {
  67.       GLuint i;
  68.       for (i = 0; i < n; i++) {
  69.          rgba[i][ACOMP] = rgba[i][ACOMP] * aScale + aBias;
  70.       }
  71.    }
  72. }
  73.  
  74.  
  75. /*
  76.  * Apply pixel mapping to an array of floating point RGBA pixels.
  77.  */
  78. void
  79. _mesa_map_rgba( const struct gl_context *ctx, GLuint n, GLfloat rgba[][4] )
  80. {
  81.    const GLfloat rscale = (GLfloat) (ctx->PixelMaps.RtoR.Size - 1);
  82.    const GLfloat gscale = (GLfloat) (ctx->PixelMaps.GtoG.Size - 1);
  83.    const GLfloat bscale = (GLfloat) (ctx->PixelMaps.BtoB.Size - 1);
  84.    const GLfloat ascale = (GLfloat) (ctx->PixelMaps.AtoA.Size - 1);
  85.    const GLfloat *rMap = ctx->PixelMaps.RtoR.Map;
  86.    const GLfloat *gMap = ctx->PixelMaps.GtoG.Map;
  87.    const GLfloat *bMap = ctx->PixelMaps.BtoB.Map;
  88.    const GLfloat *aMap = ctx->PixelMaps.AtoA.Map;
  89.    GLuint i;
  90.    for (i=0;i<n;i++) {
  91.       GLfloat r = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
  92.       GLfloat g = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
  93.       GLfloat b = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
  94.       GLfloat a = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
  95.       rgba[i][RCOMP] = rMap[IROUND(r * rscale)];
  96.       rgba[i][GCOMP] = gMap[IROUND(g * gscale)];
  97.       rgba[i][BCOMP] = bMap[IROUND(b * bscale)];
  98.       rgba[i][ACOMP] = aMap[IROUND(a * ascale)];
  99.    }
  100. }
  101.  
  102. /**
  103.  * Apply a color table lookup to an array of floating point RGBA colors.
  104.  */
  105. void
  106. _mesa_lookup_rgba_float(const struct gl_color_table *table,
  107.                         GLuint n, GLfloat rgba[][4])
  108. {
  109.    const GLint max = table->Size - 1;
  110.    const GLfloat scale = (GLfloat) max;
  111.    const GLfloat *lut = table->TableF;
  112.    GLuint i;
  113.  
  114.    if (!table->TableF || table->Size == 0)
  115.       return;
  116.  
  117.    switch (table->_BaseFormat) {
  118.       case GL_INTENSITY:
  119.          /* replace RGBA with I */
  120.          for (i = 0; i < n; i++) {
  121.             GLint j = IROUND(rgba[i][RCOMP] * scale);
  122.             GLfloat c = lut[CLAMP(j, 0, max)];
  123.             rgba[i][RCOMP] =
  124.             rgba[i][GCOMP] =
  125.             rgba[i][BCOMP] =
  126.             rgba[i][ACOMP] = c;
  127.          }
  128.          break;
  129.       case GL_LUMINANCE:
  130.          /* replace RGB with L */
  131.          for (i = 0; i < n; i++) {
  132.             GLint j = IROUND(rgba[i][RCOMP] * scale);
  133.             GLfloat c = lut[CLAMP(j, 0, max)];
  134.             rgba[i][RCOMP] =
  135.             rgba[i][GCOMP] =
  136.             rgba[i][BCOMP] = c;
  137.          }
  138.          break;
  139.       case GL_ALPHA:
  140.          /* replace A with A */
  141.          for (i = 0; i < n; i++) {
  142.             GLint j = IROUND(rgba[i][ACOMP] * scale);
  143.             rgba[i][ACOMP] = lut[CLAMP(j, 0, max)];
  144.          }
  145.          break;
  146.       case GL_LUMINANCE_ALPHA:
  147.          /* replace RGBA with LLLA */
  148.          for (i = 0; i < n; i++) {
  149.             GLint jL = IROUND(rgba[i][RCOMP] * scale);
  150.             GLint jA = IROUND(rgba[i][ACOMP] * scale);
  151.             GLfloat luminance, alpha;
  152.             jL = CLAMP(jL, 0, max);
  153.             jA = CLAMP(jA, 0, max);
  154.             luminance = lut[jL * 2 + 0];
  155.             alpha     = lut[jA * 2 + 1];
  156.             rgba[i][RCOMP] =
  157.             rgba[i][GCOMP] =
  158.             rgba[i][BCOMP] = luminance;
  159.             rgba[i][ACOMP] = alpha;;
  160.          }
  161.          break;
  162.       case GL_RED:
  163.          /* replace RGB with RGB */
  164.          for (i = 0; i < n; i++) {
  165.             GLint jR = IROUND(rgba[i][RCOMP] * scale);
  166.             jR = CLAMP(jR, 0, max);
  167.             rgba[i][RCOMP] = lut[jR * 3 + 0];
  168.          }
  169.          break;
  170.       case GL_RG:
  171.          /* replace RG with RG */
  172.          for (i = 0; i < n; i++) {
  173.             GLint jR = IROUND(rgba[i][RCOMP] * scale);
  174.             GLint jG = IROUND(rgba[i][GCOMP] * scale);
  175.             jR = CLAMP(jR, 0, max);
  176.             jG = CLAMP(jG, 0, max);
  177.             rgba[i][RCOMP] = lut[jR * 3 + 0];
  178.             rgba[i][GCOMP] = lut[jG * 3 + 1];
  179.          }
  180.          break;
  181.       case GL_RGB:
  182.          /* replace RGB with RGB */
  183.          for (i = 0; i < n; i++) {
  184.             GLint jR = IROUND(rgba[i][RCOMP] * scale);
  185.             GLint jG = IROUND(rgba[i][GCOMP] * scale);
  186.             GLint jB = IROUND(rgba[i][BCOMP] * scale);
  187.             jR = CLAMP(jR, 0, max);
  188.             jG = CLAMP(jG, 0, max);
  189.             jB = CLAMP(jB, 0, max);
  190.             rgba[i][RCOMP] = lut[jR * 3 + 0];
  191.             rgba[i][GCOMP] = lut[jG * 3 + 1];
  192.             rgba[i][BCOMP] = lut[jB * 3 + 2];
  193.          }
  194.          break;
  195.       case GL_RGBA:
  196.          /* replace RGBA with RGBA */
  197.          for (i = 0; i < n; i++) {
  198.             GLint jR = IROUND(rgba[i][RCOMP] * scale);
  199.             GLint jG = IROUND(rgba[i][GCOMP] * scale);
  200.             GLint jB = IROUND(rgba[i][BCOMP] * scale);
  201.             GLint jA = IROUND(rgba[i][ACOMP] * scale);
  202.             jR = CLAMP(jR, 0, max);
  203.             jG = CLAMP(jG, 0, max);
  204.             jB = CLAMP(jB, 0, max);
  205.             jA = CLAMP(jA, 0, max);
  206.             rgba[i][RCOMP] = lut[jR * 4 + 0];
  207.             rgba[i][GCOMP] = lut[jG * 4 + 1];
  208.             rgba[i][BCOMP] = lut[jB * 4 + 2];
  209.             rgba[i][ACOMP] = lut[jA * 4 + 3];
  210.          }
  211.          break;
  212.       default:
  213.          _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_float");
  214.          return;
  215.    }
  216. }
  217.  
  218.  
  219.  
  220. /**
  221.  * Apply a color table lookup to an array of ubyte/RGBA colors.
  222.  */
  223. void
  224. _mesa_lookup_rgba_ubyte(const struct gl_color_table *table,
  225.                         GLuint n, GLubyte rgba[][4])
  226. {
  227.    const GLubyte *lut = table->TableUB;
  228.    const GLfloat scale = (GLfloat) (table->Size - 1) / (GLfloat)255.0;
  229.    GLuint i;
  230.  
  231.    if (!table->TableUB || table->Size == 0)
  232.       return;
  233.  
  234.    switch (table->_BaseFormat) {
  235.    case GL_INTENSITY:
  236.       /* replace RGBA with I */
  237.       if (table->Size == 256) {
  238.          for (i = 0; i < n; i++) {
  239.             const GLubyte c = lut[rgba[i][RCOMP]];
  240.             rgba[i][RCOMP] =
  241.             rgba[i][GCOMP] =
  242.             rgba[i][BCOMP] =
  243.             rgba[i][ACOMP] = c;
  244.          }
  245.       }
  246.       else {
  247.          for (i = 0; i < n; i++) {
  248.             GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
  249.             rgba[i][RCOMP] =
  250.             rgba[i][GCOMP] =
  251.             rgba[i][BCOMP] =
  252.             rgba[i][ACOMP] = lut[j];
  253.          }
  254.       }
  255.       break;
  256.    case GL_LUMINANCE:
  257.       /* replace RGB with L */
  258.       if (table->Size == 256) {
  259.          for (i = 0; i < n; i++) {
  260.             const GLubyte c = lut[rgba[i][RCOMP]];
  261.             rgba[i][RCOMP] =
  262.             rgba[i][GCOMP] =
  263.             rgba[i][BCOMP] = c;
  264.          }
  265.       }
  266.       else {
  267.          for (i = 0; i < n; i++) {
  268.             GLint j = IROUND((GLfloat) rgba[i][RCOMP] * scale);
  269.             rgba[i][RCOMP] =
  270.             rgba[i][GCOMP] =
  271.             rgba[i][BCOMP] = lut[j];
  272.          }
  273.       }
  274.       break;
  275.    case GL_ALPHA:
  276.       /* replace A with A */
  277.       if (table->Size == 256) {
  278.          for (i = 0; i < n; i++) {
  279.             rgba[i][ACOMP] = lut[rgba[i][ACOMP]];
  280.          }
  281.       }
  282.       else {
  283.          for (i = 0; i < n; i++) {
  284.             GLint j = IROUND((GLfloat) rgba[i][ACOMP] * scale);
  285.             rgba[i][ACOMP] = lut[j];
  286.          }
  287.       }
  288.       break;
  289.    case GL_LUMINANCE_ALPHA:
  290.       /* replace RGBA with LLLA */
  291.       if (table->Size == 256) {
  292.          for (i = 0; i < n; i++) {
  293.             GLubyte l = lut[rgba[i][RCOMP] * 2 + 0];
  294.             GLubyte a = lut[rgba[i][ACOMP] * 2 + 1];;
  295.             rgba[i][RCOMP] =
  296.             rgba[i][GCOMP] =
  297.             rgba[i][BCOMP] = l;
  298.             rgba[i][ACOMP] = a;
  299.          }
  300.       }
  301.       else {
  302.          for (i = 0; i < n; i++) {
  303.             GLint jL = IROUND((GLfloat) rgba[i][RCOMP] * scale);
  304.             GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
  305.             GLubyte luminance = lut[jL * 2 + 0];
  306.             GLubyte alpha     = lut[jA * 2 + 1];
  307.             rgba[i][RCOMP] =
  308.             rgba[i][GCOMP] =
  309.             rgba[i][BCOMP] = luminance;
  310.             rgba[i][ACOMP] = alpha;
  311.          }
  312.       }
  313.       break;
  314.    case GL_RGB:
  315.       if (table->Size == 256) {
  316.          for (i = 0; i < n; i++) {
  317.             rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 3 + 0];
  318.             rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 3 + 1];
  319.             rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 3 + 2];
  320.          }
  321.       }
  322.       else {
  323.          for (i = 0; i < n; i++) {
  324.             GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
  325.             GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
  326.             GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
  327.             rgba[i][RCOMP] = lut[jR * 3 + 0];
  328.             rgba[i][GCOMP] = lut[jG * 3 + 1];
  329.             rgba[i][BCOMP] = lut[jB * 3 + 2];
  330.          }
  331.       }
  332.       break;
  333.    case GL_RGBA:
  334.       if (table->Size == 256) {
  335.          for (i = 0; i < n; i++) {
  336.             rgba[i][RCOMP] = lut[rgba[i][RCOMP] * 4 + 0];
  337.             rgba[i][GCOMP] = lut[rgba[i][GCOMP] * 4 + 1];
  338.             rgba[i][BCOMP] = lut[rgba[i][BCOMP] * 4 + 2];
  339.             rgba[i][ACOMP] = lut[rgba[i][ACOMP] * 4 + 3];
  340.          }
  341.       }
  342.       else {
  343.          for (i = 0; i < n; i++) {
  344.             GLint jR = IROUND((GLfloat) rgba[i][RCOMP] * scale);
  345.             GLint jG = IROUND((GLfloat) rgba[i][GCOMP] * scale);
  346.             GLint jB = IROUND((GLfloat) rgba[i][BCOMP] * scale);
  347.             GLint jA = IROUND((GLfloat) rgba[i][ACOMP] * scale);
  348.             CLAMPED_FLOAT_TO_CHAN(rgba[i][RCOMP], lut[jR * 4 + 0]);
  349.             CLAMPED_FLOAT_TO_CHAN(rgba[i][GCOMP], lut[jG * 4 + 1]);
  350.             CLAMPED_FLOAT_TO_CHAN(rgba[i][BCOMP], lut[jB * 4 + 2]);
  351.             CLAMPED_FLOAT_TO_CHAN(rgba[i][ACOMP], lut[jA * 4 + 3]);
  352.          }
  353.       }
  354.       break;
  355.    default:
  356.       _mesa_problem(NULL, "Bad format in _mesa_lookup_rgba_chan");
  357.       return;
  358.    }
  359. }
  360.  
  361.  
  362.  
  363. /*
  364.  * Map color indexes to float rgba values.
  365.  */
  366. void
  367. _mesa_map_ci_to_rgba( const struct gl_context *ctx, GLuint n,
  368.                       const GLuint index[], GLfloat rgba[][4] )
  369. {
  370.    GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
  371.    GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
  372.    GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
  373.    GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
  374.    const GLfloat *rMap = ctx->PixelMaps.ItoR.Map;
  375.    const GLfloat *gMap = ctx->PixelMaps.ItoG.Map;
  376.    const GLfloat *bMap = ctx->PixelMaps.ItoB.Map;
  377.    const GLfloat *aMap = ctx->PixelMaps.ItoA.Map;
  378.    GLuint i;
  379.    for (i=0;i<n;i++) {
  380.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  381.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  382.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  383.       rgba[i][ACOMP] = aMap[index[i] & amask];
  384.    }
  385. }
  386.  
  387.  
  388. /**
  389.  * Map ubyte color indexes to ubyte/RGBA values.
  390.  */
  391. void
  392. _mesa_map_ci8_to_rgba8(const struct gl_context *ctx,
  393.                        GLuint n, const GLubyte index[],
  394.                        GLubyte rgba[][4])
  395. {
  396.    GLuint rmask = ctx->PixelMaps.ItoR.Size - 1;
  397.    GLuint gmask = ctx->PixelMaps.ItoG.Size - 1;
  398.    GLuint bmask = ctx->PixelMaps.ItoB.Size - 1;
  399.    GLuint amask = ctx->PixelMaps.ItoA.Size - 1;
  400.    const GLubyte *rMap = ctx->PixelMaps.ItoR.Map8;
  401.    const GLubyte *gMap = ctx->PixelMaps.ItoG.Map8;
  402.    const GLubyte *bMap = ctx->PixelMaps.ItoB.Map8;
  403.    const GLubyte *aMap = ctx->PixelMaps.ItoA.Map8;
  404.    GLuint i;
  405.    for (i=0;i<n;i++) {
  406.       rgba[i][RCOMP] = rMap[index[i] & rmask];
  407.       rgba[i][GCOMP] = gMap[index[i] & gmask];
  408.       rgba[i][BCOMP] = bMap[index[i] & bmask];
  409.       rgba[i][ACOMP] = aMap[index[i] & amask];
  410.    }
  411. }
  412.  
  413.  
  414. void
  415. _mesa_scale_and_bias_depth(const struct gl_context *ctx, GLuint n,
  416.                            GLfloat depthValues[])
  417. {
  418.    const GLfloat scale = ctx->Pixel.DepthScale;
  419.    const GLfloat bias = ctx->Pixel.DepthBias;
  420.    GLuint i;
  421.    for (i = 0; i < n; i++) {
  422.       GLfloat d = depthValues[i] * scale + bias;
  423.       depthValues[i] = CLAMP(d, 0.0F, 1.0F);
  424.    }
  425. }
  426.  
  427.  
  428. void
  429. _mesa_scale_and_bias_depth_uint(const struct gl_context *ctx, GLuint n,
  430.                                 GLuint depthValues[])
  431. {
  432.    const GLdouble max = (double) 0xffffffff;
  433.    const GLdouble scale = ctx->Pixel.DepthScale;
  434.    const GLdouble bias = ctx->Pixel.DepthBias * max;
  435.    GLuint i;
  436.    for (i = 0; i < n; i++) {
  437.       GLdouble d = (GLdouble) depthValues[i] * scale + bias;
  438.       d = CLAMP(d, 0.0, max);
  439.       depthValues[i] = (GLuint) d;
  440.    }
  441. }
  442.  
  443. /**
  444.  * Apply various pixel transfer operations to an array of RGBA pixels
  445.  * as indicated by the transferOps bitmask
  446.  */
  447. void
  448. _mesa_apply_rgba_transfer_ops(struct gl_context *ctx, GLbitfield transferOps,
  449.                               GLuint n, GLfloat rgba[][4])
  450. {
  451.    /* scale & bias */
  452.    if (transferOps & IMAGE_SCALE_BIAS_BIT) {
  453.       _mesa_scale_and_bias_rgba(n, rgba,
  454.                                 ctx->Pixel.RedScale, ctx->Pixel.GreenScale,
  455.                                 ctx->Pixel.BlueScale, ctx->Pixel.AlphaScale,
  456.                                 ctx->Pixel.RedBias, ctx->Pixel.GreenBias,
  457.                                 ctx->Pixel.BlueBias, ctx->Pixel.AlphaBias);
  458.    }
  459.    /* color map lookup */
  460.    if (transferOps & IMAGE_MAP_COLOR_BIT) {
  461.       _mesa_map_rgba( ctx, n, rgba );
  462.    }
  463.  
  464.    /* clamping to [0,1] */
  465.    if (transferOps & IMAGE_CLAMP_BIT) {
  466.       GLuint i;
  467.       for (i = 0; i < n; i++) {
  468.          rgba[i][RCOMP] = CLAMP(rgba[i][RCOMP], 0.0F, 1.0F);
  469.          rgba[i][GCOMP] = CLAMP(rgba[i][GCOMP], 0.0F, 1.0F);
  470.          rgba[i][BCOMP] = CLAMP(rgba[i][BCOMP], 0.0F, 1.0F);
  471.          rgba[i][ACOMP] = CLAMP(rgba[i][ACOMP], 0.0F, 1.0F);
  472.       }
  473.    }
  474. }
  475.  
  476.  
  477. /*
  478.  * Apply color index shift and offset to an array of pixels.
  479.  */
  480. void
  481. _mesa_shift_and_offset_ci(const struct gl_context *ctx,
  482.                           GLuint n, GLuint indexes[])
  483. {
  484.    GLint shift = ctx->Pixel.IndexShift;
  485.    GLint offset = ctx->Pixel.IndexOffset;
  486.    GLuint i;
  487.    if (shift > 0) {
  488.       for (i=0;i<n;i++) {
  489.          indexes[i] = (indexes[i] << shift) + offset;
  490.       }
  491.    }
  492.    else if (shift < 0) {
  493.       shift = -shift;
  494.       for (i=0;i<n;i++) {
  495.          indexes[i] = (indexes[i] >> shift) + offset;
  496.       }
  497.    }
  498.    else {
  499.       for (i=0;i<n;i++) {
  500.          indexes[i] = indexes[i] + offset;
  501.       }
  502.    }
  503. }
  504.  
  505.  
  506.  
  507. /**
  508.  * Apply color index shift, offset and table lookup to an array
  509.  * of color indexes;
  510.  */
  511. void
  512. _mesa_apply_ci_transfer_ops(const struct gl_context *ctx,
  513.                             GLbitfield transferOps,
  514.                             GLuint n, GLuint indexes[])
  515. {
  516.    if (transferOps & IMAGE_SHIFT_OFFSET_BIT) {
  517.       _mesa_shift_and_offset_ci(ctx, n, indexes);
  518.    }
  519.    if (transferOps & IMAGE_MAP_COLOR_BIT) {
  520.       const GLuint mask = ctx->PixelMaps.ItoI.Size - 1;
  521.       GLuint i;
  522.       for (i = 0; i < n; i++) {
  523.          const GLuint j = indexes[i] & mask;
  524.          indexes[i] = IROUND(ctx->PixelMaps.ItoI.Map[j]);
  525.       }
  526.    }
  527. }
  528.  
  529.  
  530. /**
  531.  * Apply stencil index shift, offset and table lookup to an array
  532.  * of stencil values.
  533.  */
  534. void
  535. _mesa_apply_stencil_transfer_ops(const struct gl_context *ctx, GLuint n,
  536.                                  GLstencil stencil[])
  537. {
  538.    if (ctx->Pixel.IndexShift != 0 || ctx->Pixel.IndexOffset != 0) {
  539.       const GLint offset = ctx->Pixel.IndexOffset;
  540.       GLint shift = ctx->Pixel.IndexShift;
  541.       GLuint i;
  542.       if (shift > 0) {
  543.          for (i = 0; i < n; i++) {
  544.             stencil[i] = (stencil[i] << shift) + offset;
  545.          }
  546.       }
  547.       else if (shift < 0) {
  548.          shift = -shift;
  549.          for (i = 0; i < n; i++) {
  550.             stencil[i] = (stencil[i] >> shift) + offset;
  551.          }
  552.       }
  553.       else {
  554.          for (i = 0; i < n; i++) {
  555.             stencil[i] = stencil[i] + offset;
  556.          }
  557.       }
  558.    }
  559.    if (ctx->Pixel.MapStencilFlag) {
  560.       GLuint mask = ctx->PixelMaps.StoS.Size - 1;
  561.       GLuint i;
  562.       for (i = 0; i < n; i++) {
  563.          stencil[i] = (GLstencil)ctx->PixelMaps.StoS.Map[ stencil[i] & mask ];
  564.       }
  565.    }
  566. }
  567.