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 FillBitmap(__GLXcontext *gc, GLint width, GLint height,
  84                        GLenum format, const GLvoid *userdata,
  85                        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     } else {
 101         groupsPerRow = width;
 102     }
 103     components = __glElementsPerGroup(format,GL_BITMAP);
 104     rowSize = (groupsPerRow * components + 7) >> 3;
 105     padding = (rowSize % alignment);
 106     if (padding) {
 107         rowSize += alignment - padding;
 108     }
 109     start = ((const GLubyte*) userdata) + skipRows * rowSize +
 110         ((skipPixels * components) >> 3);
 111     bitOffset = (skipPixels * components) & 7;
 112     highBitMask = LowBitsMask[8-bitOffset];
 113     lowBitMask = HighBitsMask[bitOffset];
 114     elementsPerRow = width * components;
 115     for (i = 0; i < height; i++) {
 116         elementsLeft = elementsPerRow;
 117         iter = start;
 118         while (elementsLeft) {
 119             /* First retrieve low bits from current byte */
 120             if (lsbFirst) {
 121                 currentByte = MsbToLsbTable[iter[0]];
 122             } else {
 123                 currentByte = iter[0];
 124             }
 125             if (bitOffset) {
 126                 /* Need to read next byte to finish current byte */
 127                 if (elementsLeft > (8 - bitOffset)) {
 128                     if (lsbFirst) {
 129                         nextByte = MsbToLsbTable[iter[1]];
 130                     } else {
 131                         nextByte = iter[1];
 132                     }
 133                     currentByte =
 134                         ((currentByte & highBitMask) << bitOffset) |
 135                             ((nextByte & lowBitMask) >> (8 - bitOffset));
 136                 } else {
 137                     currentByte =
 138                         ((currentByte & highBitMask) << bitOffset);
 139                 }
 140             }
 141             if (elementsLeft >= 8) {
 142                 *destImage = currentByte;
 143                 elementsLeft -= 8;
 144             } else {
 145                 *destImage = currentByte & HighBitsMask[elementsLeft];
 146                 elementsLeft = 0;
 147             }
 148             destImage++;
 149             iter++;
 150         }
 151         start += rowSize;
 152     }
 153 }
 154
 155 /*
 156 ** Extract array from user's data applying all pixel store modes.
 157 ** The internal packed array format used has LSB_FIRST = FALSE and
 158 ** ALIGNMENT = 1.
 159 */
 160 void __glFillImage(__GLXcontext *gc, GLint dim, GLint width, GLint height,
 161                    GLint depth, GLenum format, GLenum type,
 162                    const GLvoid *userdata, GLubyte *newimage, GLubyte *modes)
 163 {
 164     const __GLXattribute * state = gc->client_state_private;
 165     GLint rowLength = state->storeUnpack.rowLength;
 166     GLint imageHeight = state->storeUnpack.imageHeight;
 167     GLint alignment = state->storeUnpack.alignment;
 168     GLint skipPixels = state->storeUnpack.skipPixels;
 169     GLint skipRows = state->storeUnpack.skipRows;
 170     GLint skipImages = state->storeUnpack.skipImages;
 171     GLint swapBytes = state->storeUnpack.swapEndian;
 172     GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
 173     GLint elementsPerRow, imageSize, rowsPerImage, h, i, j, k;
 174     const GLubyte *start, *iter, *itera, *iterb, *iterc;
 175     GLubyte *iter2;
 176
 177     if (type == GL_BITMAP) {
 178         FillBitmap(gc, width, height, format, userdata, newimage);
 179     } else {
 180         components = __glElementsPerGroup(format,type);
 181         if (rowLength > 0) {
 182             groupsPerRow = rowLength;
 183         } else {
 184             groupsPerRow = width;
 185         }
 186         if (imageHeight > 0) {
 187             rowsPerImage = imageHeight;
 188         } else {
 189             rowsPerImage = height;
 190         }
 191
 192         elementSize = __glBytesPerElement(type);
 193         groupSize = elementSize * components;
 194         if (elementSize == 1) swapBytes = 0;
 195
 196         rowSize = groupsPerRow * groupSize;
 197         padding = (rowSize % alignment);
 198         if (padding) {
 199             rowSize += alignment - padding;
 200         }
 201         imageSize = rowSize * rowsPerImage;
 202         start = ((const GLubyte*) userdata) + skipImages * imageSize +
 203                 skipRows * rowSize + skipPixels * groupSize;
 204         iter2 = newimage;
 205         elementsPerRow = width * components;
 206
 207         if (swapBytes) {
 208             itera = start;
 209             for (h = 0; h < depth; h++) {
 210                 iterb = itera;
 211                 for (i = 0; i < height; i++) {
 212                     iterc = iterb;
 213                     for (j = 0; j < elementsPerRow; j++) {
 214                         for (k = 1; k <= elementSize; k++) {
 215                             iter2[k-1] = iterc[elementSize - k];
 216                         }
 217                         iter2 += elementSize;
 218                         iterc += elementSize;
 219                     }
 220                     iterb += rowSize;
 221                 }
 222                 itera += imageSize;
 223             }
 224         } else {
 225             itera = start;
 226             for (h = 0; h < depth; h++) {
 227                 if (rowSize == elementsPerRow * elementSize) {
 228                     /* Ha!  This is mondo easy! */
 229                     __GLX_MEM_COPY(iter2, itera,
 230                                    elementsPerRow * elementSize * height);
 231                     iter2 += elementsPerRow * elementSize * height;
 232                 } else {
 233                     iter = itera;
 234                     for (i = 0; i < height; i++) {
 235                         __GLX_MEM_COPY(iter2, iter, elementsPerRow*elementSize);
 236                         iter2 += elementsPerRow * elementSize;
 237                         iter += rowSize;
 238                     }
 239                 }
 240                 itera += imageSize;
 241             }
 242         }
 243     }
 244
 245     /* Setup store modes that describe what we just did */
 246     if (modes) {
 247        if ( dim < 3 ) {
 248           (void) memcpy( modes, __glXDefaultPixelStore + 4, 20 );
 249        }
 250        else {
 251           (void) memcpy( modes, __glXDefaultPixelStore + 0, 36 );
 252        }
 253     }
 254 }
 255
 256 /*
 257 ** Empty a bitmap in LSB_FIRST=GL_FALSE and ALIGNMENT=4 format packing it
 258 ** into the clients memory using the pixel store PACK modes.
 259 */
 260 static void EmptyBitmap(__GLXcontext *gc, GLint width, GLint height,
 261                         GLenum format, const GLubyte *sourceImage,
 262                         GLvoid *userdata)
 263 {
 264     const __GLXattribute * state = gc->client_state_private;
 265     GLint rowLength = state->storePack.rowLength;
 266     GLint alignment = state->storePack.alignment;
 267     GLint skipPixels = state->storePack.skipPixels;
 268     GLint skipRows = state->storePack.skipRows;
 269     GLint lsbFirst = state->storePack.lsbFirst;
 270     GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
 271     GLint sourceRowSize, sourcePadding, sourceSkip;
 272     GLubyte *start, *iter;
 273     GLint elementsLeft, bitOffset, currentByte, highBitMask, lowBitMask;
 274     GLint writeMask, i;
 275     GLubyte writeByte;
 276
 277     components = __glElementsPerGroup(format,GL_BITMAP);
 278     if (rowLength > 0) {
 279         groupsPerRow = rowLength;
 280     } else {
 281         groupsPerRow = width;
 282     }
 283
 284     rowSize = (groupsPerRow * components + 7) >> 3;
 285     padding = (rowSize % alignment);
 286     if (padding) {
 287         rowSize += alignment - padding;
 288     }
 289     sourceRowSize = (width * components + 7) >> 3;
 290     sourcePadding = (sourceRowSize % 4);
 291     if (sourcePadding) {
 292         sourceSkip = 4 - sourcePadding;
 293     } else {
 294         sourceSkip = 0;
 295     }
 296     start = ((GLubyte*) userdata) + skipRows * rowSize +
 297         ((skipPixels * components) >> 3);
 298     bitOffset = (skipPixels * components) & 7;
 299     highBitMask = LowBitsMask[8-bitOffset];
 300     lowBitMask = HighBitsMask[bitOffset];
 301     elementsPerRow = width * components;
 302     for (i = 0; i < height; i++) {
 303         elementsLeft = elementsPerRow;
 304         iter = start;
 305         writeMask = highBitMask;
 306         writeByte = 0;
 307         while (elementsLeft) {
 308             /* Set up writeMask (to write to current byte) */
 309             if (elementsLeft + bitOffset < 8) {
 310                 /* Need to trim writeMask */
 311                 writeMask &= HighBitsMask[bitOffset+elementsLeft];
 312             }
 313
 314             if (lsbFirst) {
 315                 currentByte = MsbToLsbTable[iter[0]];
 316             } else {
 317                 currentByte = iter[0];
 318             }
 319
 320             if (bitOffset) {
 321                 writeByte |= (sourceImage[0] >> bitOffset);
 322                 currentByte = (currentByte & ~writeMask) |
 323                     (writeByte & writeMask);
 324                 writeByte = (sourceImage[0] << (8 - bitOffset));
 325             } else {
 326                 currentByte = (currentByte & ~writeMask) |
 327                     (sourceImage[0] & writeMask);
 328             }
 329
 330             if (lsbFirst) {
 331                 iter[0] = MsbToLsbTable[currentByte];
 332             } else {
 333                 iter[0] = currentByte;
 334             }
 335
 336             if (elementsLeft >= 8) {
 337                 elementsLeft -= 8;
 338             } else {
 339                 elementsLeft = 0;
 340             }
 341             sourceImage++;
 342             iter++;
 343             writeMask = 0xff;
 344         }
 345         if (writeByte) {
 346             /* Some data left over that still needs writing */
 347             writeMask &= lowBitMask;
 348             if (lsbFirst) {
 349                 currentByte = MsbToLsbTable[iter[0]];
 350             } else {
 351                 currentByte = iter[0];
 352             }
 353             currentByte = (currentByte & ~writeMask) | (writeByte & writeMask);
 354             if (lsbFirst) {
 355                 iter[0] = MsbToLsbTable[currentByte];
 356             } else {
 357                 iter[0] = currentByte;
 358             }
 359         }
 360         start += rowSize;
 361         sourceImage += sourceSkip;
 362     }
 363 }
 364
 365 /*
 366 ** Insert array into user's data applying all pixel store modes.
 367 ** The packed array format from the server is LSB_FIRST = FALSE,
 368 ** SWAP_BYTES = the current pixel storage pack mode, and ALIGNMENT = 4.
 369 ** Named __glEmptyImage() because it is the opposite of __glFillImage().
 370 */
 371 /* ARGSUSED */
 372 void __glEmptyImage(__GLXcontext *gc, GLint dim, GLint width, GLint height,
 373                     GLint depth, GLenum format, GLenum type,
 374                     const GLubyte *sourceImage, GLvoid *userdata)
 375 {
 376     const __GLXattribute * state = gc->client_state_private;
 377     GLint rowLength = state->storePack.rowLength;
 378     GLint imageHeight = state->storePack.imageHeight;
 379     GLint alignment = state->storePack.alignment;
 380     GLint skipPixels = state->storePack.skipPixels;
 381     GLint skipRows = state->storePack.skipRows;
 382     GLint skipImages = state->storePack.skipImages;
 383     GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
 384     GLint elementsPerRow, sourceRowSize, sourcePadding, h, i;
 385     GLint imageSize, rowsPerImage;
 386     GLubyte *start, *iter, *itera;
 387
 388     if (type == GL_BITMAP) {
 389         EmptyBitmap(gc, width, height, format, sourceImage, userdata);
 390     } else {
 391         components = __glElementsPerGroup(format,type);
 392         if (rowLength > 0) {
 393             groupsPerRow = rowLength;
 394         } else {
 395             groupsPerRow = width;
 396         }
 397         if (imageHeight > 0) {
 398             rowsPerImage = imageHeight;
 399         } else {
 400             rowsPerImage = height;
 401         }
 402         elementSize = __glBytesPerElement(type);
 403         groupSize = elementSize * components;
 404         rowSize = groupsPerRow * groupSize;
 405         padding = (rowSize % alignment);
 406         if (padding) {
 407             rowSize += alignment - padding;
 408         }
 409         sourceRowSize = width * groupSize;
 410         sourcePadding = (sourceRowSize % 4);
 411         if (sourcePadding) {
 412             sourceRowSize += 4 - sourcePadding;
 413         }
 414         imageSize = sourceRowSize * rowsPerImage;
 415         start = ((GLubyte*) userdata) + skipImages * imageSize +
 416                 skipRows * rowSize + skipPixels * groupSize;
 417         elementsPerRow = width * components;
 418
 419         itera = start;
 420         for (h = 0; h < depth; h++) {
 421             if ((rowSize == sourceRowSize) && (sourcePadding == 0)) {
 422                 /* Ha!  This is mondo easy! */
 423                 __GLX_MEM_COPY(itera, sourceImage,
 424                                elementsPerRow * elementSize * height);
 425                 sourceImage += elementsPerRow * elementSize * height;
 426             } else {
 427                 iter = itera;
 428                 for (i = 0; i < height; i++) {
 429                     __GLX_MEM_COPY(iter, sourceImage,
 430                                    elementsPerRow * elementSize);
 431                     sourceImage += sourceRowSize;
 432                     iter += rowSize;
 433                 }
 434             }
 435             itera += imageSize;
 436         }
 437     }
 438 }