src/glx/x11/pixel.c

   1 /* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
   2 /*
   3  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   4  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "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 including the dates of first publication and
  14  * either this permission notice or a reference to
  15  * http://oss.sgi.com/projects/FreeB/
  16  * shall be included in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  23  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  *
  26  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  27  * shall not be used in advertising or otherwise to promote the sale, use or
  28  * other dealings in this Software without prior written authorization from
  29  * Silicon Graphics, Inc.
  30  */
  31
  32 #include "packrender.h"
  33
  34 static const GLubyte MsbToLsbTable[256] = {
  35    0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
  36    0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
  37    0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
  38    0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
  39    0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
  40    0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
  41    0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
  42    0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
  43    0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
  44    0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
  45    0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
  46    0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
  47    0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
  48    0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
  49    0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
  50    0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
  51    0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
  52    0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
  53    0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
  54    0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
  55    0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
  56    0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
  57    0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
  58    0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
  59    0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
  60    0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
  61    0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
  62    0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
  63    0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
  64    0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
  65    0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
  66    0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
  67 };
  68
  69 static const GLubyte LowBitsMask[9] = {
  70    0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff,
  71 };
  72
  73 static const GLubyte HighBitsMask[9] = {
  74    0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
  75 };
  76
  77
  78 /*
  79 ** Copy bitmap data from clients packed memory applying unpacking modes as the
  80 ** data is transfered into the destImage buffer.  Return in modes the
  81 ** set of pixel modes that are to be done by the server.
  82 */
  83 static void
  84 FillBitmap(__GLXcontext * gc, GLint width, GLint height,
  85            GLenum format, const GLvoid * userdata, GLubyte * destImage)
  86 {
  87    const __GLXattribute *state = gc->client_state_private;
  88    GLint rowLength = state->storeUnpack.rowLength;
  89    GLint alignment = state->storeUnpack.alignment;
  90    GLint skipPixels = state->storeUnpack.skipPixels;
  91    GLint skipRows = state->storeUnpack.skipRows;
  92    GLint lsbFirst = state->storeUnpack.lsbFirst;
  93    GLint elementsLeft, bitOffset, currentByte, nextByte, highBitMask;
  94    GLint lowBitMask, i;
  95    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
  96    const GLubyte *start, *iter;
  97
  98    if (rowLength > 0) {
  99       groupsPerRow = rowLength;
 100    }
 101    else {
 102       groupsPerRow = width;
 103    }
 104    components = __glElementsPerGroup(format, GL_BITMAP);
 105    rowSize = (groupsPerRow * components + 7) >> 3;
 106    padding = (rowSize % alignment);
 107    if (padding) {
 108       rowSize += alignment - padding;
 109    }
 110    start = ((const GLubyte *) userdata) + skipRows * rowSize +
 111       ((skipPixels * components) >> 3);
 112    bitOffset = (skipPixels * components) & 7;
 113    highBitMask = LowBitsMask[8 - bitOffset];
 114    lowBitMask = HighBitsMask[bitOffset];
 115    elementsPerRow = width * components;
 116    for (i = 0; i < height; i++) {
 117       elementsLeft = elementsPerRow;
 118       iter = start;
 119       while (elementsLeft) {
 120          /* First retrieve low bits from current byte */
 121          if (lsbFirst) {
 122             currentByte = MsbToLsbTable[iter[0]];
 123          }
 124          else {
 125             currentByte = iter[0];
 126          }
 127          if (bitOffset) {
 128             /* Need to read next byte to finish current byte */
 129             if (elementsLeft > (8 - bitOffset)) {
 130                if (lsbFirst) {
 131                   nextByte = MsbToLsbTable[iter[1]];
 132                }
 133                else {
 134                   nextByte = iter[1];
 135                }
 136                currentByte =
 137                   ((currentByte & highBitMask) << bitOffset) |
 138                   ((nextByte & lowBitMask) >> (8 - bitOffset));
 139             }
 140             else {
 141                currentByte = ((currentByte & highBitMask) << bitOffset);
 142             }
 143          }
 144          if (elementsLeft >= 8) {
 145             *destImage = currentByte;
 146             elementsLeft -= 8;
 147          }
 148          else {
 149             *destImage = currentByte & HighBitsMask[elementsLeft];
 150             elementsLeft = 0;
 151          }
 152          destImage++;
 153          iter++;
 154       }
 155       start += rowSize;
 156    }
 157 }
 158
 159 /*
 160 ** Extract array from user's data applying all pixel store modes.
 161 ** The internal packed array format used has LSB_FIRST = FALSE and
 162 ** ALIGNMENT = 1.
 163 */
 164 void
 165 __glFillImage(__GLXcontext * gc, GLint dim, GLint width, GLint height,
 166               GLint depth, GLenum format, GLenum type,
 167               const GLvoid * userdata, GLubyte * newimage, GLubyte * modes)
 168 {
 169    const __GLXattribute *state = gc->client_state_private;
 170    GLint rowLength = state->storeUnpack.rowLength;
 171    GLint imageHeight = state->storeUnpack.imageHeight;
 172    GLint alignment = state->storeUnpack.alignment;
 173    GLint skipPixels = state->storeUnpack.skipPixels;
 174    GLint skipRows = state->storeUnpack.skipRows;
 175    GLint skipImages = state->storeUnpack.skipImages;
 176    GLint swapBytes = state->storeUnpack.swapEndian;
 177    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
 178    GLint elementsPerRow, imageSize, rowsPerImage, h, i, j, k;
 179    const GLubyte *start, *iter, *itera, *iterb, *iterc;
 180    GLubyte *iter2;
 181
 182    if (type == GL_BITMAP) {
 183       FillBitmap(gc, width, height, format, userdata, newimage);
 184    }
 185    else {
 186       components = __glElementsPerGroup(format, type);
 187       if (rowLength > 0) {
 188          groupsPerRow = rowLength;
 189       }
 190       else {
 191          groupsPerRow = width;
 192       }
 193       if (imageHeight > 0) {
 194          rowsPerImage = imageHeight;
 195       }
 196       else {
 197          rowsPerImage = height;
 198       }
 199
 200       elementSize = __glBytesPerElement(type);
 201       groupSize = elementSize * components;
 202       if (elementSize == 1)
 203          swapBytes = 0;
 204
 205       rowSize = groupsPerRow * groupSize;
 206       padding = (rowSize % alignment);
 207       if (padding) {
 208          rowSize += alignment - padding;
 209       }
 210       imageSize = rowSize * rowsPerImage;
 211       start = ((const GLubyte *) userdata) + skipImages * imageSize +
 212          skipRows * rowSize + skipPixels * groupSize;
 213       iter2 = newimage;
 214       elementsPerRow = width * components;
 215
 216       if (swapBytes) {
 217          itera = start;
 218          for (h = 0; h < depth; h++) {
 219             iterb = itera;
 220             for (i = 0; i < height; i++) {
 221                iterc = iterb;
 222                for (j = 0; j < elementsPerRow; j++) {
 223                   for (k = 1; k <= elementSize; k++) {
 224                      iter2[k - 1] = iterc[elementSize - k];
 225                   }
 226                   iter2 += elementSize;
 227                   iterc += elementSize;
 228                }
 229                iterb += rowSize;
 230             }
 231             itera += imageSize;
 232          }
 233       }
 234       else {
 235          itera = start;
 236          for (h = 0; h < depth; h++) {
 237             if (rowSize == elementsPerRow * elementSize) {
 238                /* Ha!  This is mondo easy! */
 239                __GLX_MEM_COPY(iter2, itera,
 240                               elementsPerRow * elementSize * height);
 241                iter2 += elementsPerRow * elementSize * height;
 242             }
 243             else {
 244                iter = itera;
 245                for (i = 0; i < height; i++) {
 246                   __GLX_MEM_COPY(iter2, iter, elementsPerRow * elementSize);
 247                   iter2 += elementsPerRow * elementSize;
 248                   iter += rowSize;
 249                }
 250             }
 251             itera += imageSize;
 252          }
 253       }
 254    }
 255
 256    /* Setup store modes that describe what we just did */
 257    if (modes) {
 258       if (dim < 3) {
 259          (void) memcpy(modes, __glXDefaultPixelStore + 4, 20);
 260       }
 261       else {
 262          (void) memcpy(modes, __glXDefaultPixelStore + 0, 36);
 263       }
 264    }
 265 }
 266
 267 /*
 268 ** Empty a bitmap in LSB_FIRST=GL_FALSE and ALIGNMENT=4 format packing it
 269 ** into the clients memory using the pixel store PACK modes.
 270 */
 271 static void
 272 EmptyBitmap(__GLXcontext * gc, GLint width, GLint height,
 273             GLenum format, const GLubyte * sourceImage, GLvoid * userdata)
 274 {
 275    const __GLXattribute *state = gc->client_state_private;
 276    GLint rowLength = state->storePack.rowLength;
 277    GLint alignment = state->storePack.alignment;
 278    GLint skipPixels = state->storePack.skipPixels;
 279    GLint skipRows = state->storePack.skipRows;
 280    GLint lsbFirst = state->storePack.lsbFirst;
 281    GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
 282    GLint sourceRowSize, sourcePadding, sourceSkip;
 283    GLubyte *start, *iter;
 284    GLint elementsLeft, bitOffset, currentByte, highBitMask, lowBitMask;
 285    GLint writeMask, i;
 286    GLubyte writeByte;
 287
 288    components = __glElementsPerGroup(format, GL_BITMAP);
 289    if (rowLength > 0) {
 290       groupsPerRow = rowLength;
 291    }
 292    else {
 293       groupsPerRow = width;
 294    }
 295
 296    rowSize = (groupsPerRow * components + 7) >> 3;
 297    padding = (rowSize % alignment);
 298    if (padding) {
 299       rowSize += alignment - padding;
 300    }
 301    sourceRowSize = (width * components + 7) >> 3;
 302    sourcePadding = (sourceRowSize % 4);
 303    if (sourcePadding) {
 304       sourceSkip = 4 - sourcePadding;
 305    }
 306    else {
 307       sourceSkip = 0;
 308    }
 309    start = ((GLubyte *) userdata) + skipRows * rowSize +
 310       ((skipPixels * components) >> 3);
 311    bitOffset = (skipPixels * components) & 7;
 312    highBitMask = LowBitsMask[8 - bitOffset];
 313    lowBitMask = HighBitsMask[bitOffset];
 314    elementsPerRow = width * components;
 315    for (i = 0; i < height; i++) {
 316       elementsLeft = elementsPerRow;
 317       iter = start;
 318       writeMask = highBitMask;
 319       writeByte = 0;
 320       while (elementsLeft) {
 321          /* Set up writeMask (to write to current byte) */
 322          if (elementsLeft + bitOffset < 8) {
 323             /* Need to trim writeMask */
 324             writeMask &= HighBitsMask[bitOffset + elementsLeft];
 325          }
 326
 327          if (lsbFirst) {
 328             currentByte = MsbToLsbTable[iter[0]];
 329          }
 330          else {
 331             currentByte = iter[0];
 332          }
 333
 334          if (bitOffset) {
 335             writeByte |= (sourceImage[0] >> bitOffset);
 336             currentByte = (currentByte & ~writeMask) |
 337                (writeByte & writeMask);
 338             writeByte = (sourceImage[0] << (8 - bitOffset));
 339          }
 340          else {
 341             currentByte = (currentByte & ~writeMask) |
 342                (sourceImage[0] & writeMask);
 343          }
 344
 345          if (lsbFirst) {
 346             iter[0] = MsbToLsbTable[currentByte];
 347          }
 348          else {
 349             iter[0] = currentByte;
 350          }
 351
 352          if (elementsLeft >= 8) {
 353             elementsLeft -= 8;
 354          }
 355          else {
 356             elementsLeft = 0;
 357          }
 358          sourceImage++;
 359          iter++;
 360          writeMask = 0xff;
 361       }
 362       if (writeByte) {
 363          /* Some data left over that still needs writing */
 364          writeMask &= lowBitMask;
 365          if (lsbFirst) {
 366             currentByte = MsbToLsbTable[iter[0]];
 367          }
 368          else {
 369             currentByte = iter[0];
 370          }
 371          currentByte = (currentByte & ~writeMask) | (writeByte & writeMask);
 372          if (lsbFirst) {
 373             iter[0] = MsbToLsbTable[currentByte];
 374          }
 375          else {
 376             iter[0] = currentByte;
 377          }
 378       }
 379       start += rowSize;
 380       sourceImage += sourceSkip;
 381    }
 382 }
 383
 384 /*
 385 ** Insert array into user's data applying all pixel store modes.
 386 ** The packed array format from the server is LSB_FIRST = FALSE,
 387 ** SWAP_BYTES = the current pixel storage pack mode, and ALIGNMENT = 4.
 388 ** Named __glEmptyImage() because it is the opposite of __glFillImage().
 389 */
 390 /* ARGSUSED */
 391 void
 392 __glEmptyImage(__GLXcontext * gc, GLint dim, GLint width, GLint height,
 393                GLint depth, GLenum format, GLenum type,
 394                const GLubyte * sourceImage, GLvoid * userdata)
 395 {
 396    const __GLXattribute *state = gc->client_state_private;
 397    GLint rowLength = state->storePack.rowLength;
 398    GLint imageHeight = state->storePack.imageHeight;
 399    GLint alignment = state->storePack.alignment;
 400    GLint skipPixels = state->storePack.skipPixels;
 401    GLint skipRows = state->storePack.skipRows;
 402    GLint skipImages = state->storePack.skipImages;
 403    GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
 404    GLint elementsPerRow, sourceRowSize, sourcePadding, h, i;
 405    GLint imageSize, rowsPerImage;
 406    GLubyte *start, *iter, *itera;
 407
 408    if (type == GL_BITMAP) {
 409       EmptyBitmap(gc, width, height, format, sourceImage, userdata);
 410    }
 411    else {
 412       components = __glElementsPerGroup(format, type);
 413       if (rowLength > 0) {
 414          groupsPerRow = rowLength;
 415       }
 416       else {
 417          groupsPerRow = width;
 418       }
 419       if (imageHeight > 0) {
 420          rowsPerImage = imageHeight;
 421       }
 422       else {
 423          rowsPerImage = height;
 424       }
 425       elementSize = __glBytesPerElement(type);
 426       groupSize = elementSize * components;
 427       rowSize = groupsPerRow * groupSize;
 428       padding = (rowSize % alignment);
 429       if (padding) {
 430          rowSize += alignment - padding;
 431       }
 432       sourceRowSize = width * groupSize;
 433       sourcePadding = (sourceRowSize % 4);
 434       if (sourcePadding) {
 435          sourceRowSize += 4 - sourcePadding;
 436       }
 437       imageSize = sourceRowSize * rowsPerImage;
 438       start = ((GLubyte *) userdata) + skipImages * imageSize +
 439          skipRows * rowSize + skipPixels * groupSize;
 440       elementsPerRow = width * components;
 441
 442       itera = start;
 443       for (h = 0; h < depth; h++) {
 444          if ((rowSize == sourceRowSize) && (sourcePadding == 0)) {
 445             /* Ha!  This is mondo easy! */
 446             __GLX_MEM_COPY(itera, sourceImage,
 447                            elementsPerRow * elementSize * height);
 448             sourceImage += elementsPerRow * elementSize * height;
 449          }
 450          else {
 451             iter = itera;
 452             for (i = 0; i < height; i++) {
 453                __GLX_MEM_COPY(iter, sourceImage,
 454                               elementsPerRow * elementSize);
 455                sourceImage += sourceRowSize;
 456                iter += rowSize;
 457             }
 458          }
 459          itera += imageSize;
 460       }
 461    }
 462 }