2004-10-25 22:09:16 +01:00
|
|
|
/*
|
Update to SGI FreeB 2.0.
Under the terms of version 1.1, "once Covered Code has been published
under a particular version of the License, Recipient may, for the
duration of the License, continue to use it under the terms of that
version, or choose to use such Covered Code under the terms of any
subsequent version published by SGI."
FreeB 2.0 license refers to "dates of first publication". They are here
taken to be 1991-2000, as noted in the original license text:
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
Official FreeB 2.0 text:
http://oss.sgi.com/projects/FreeB/SGIFreeSWLicB.2.0.pdf
As always, this code has not been tested for conformance with the OpenGL
specification. OpenGL conformance testing is available from
http://khronos.org/ and is required for use of the OpenGL logo in
product advertising and promotion.
2008-09-19 22:16:53 +01:00
|
|
|
* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
|
|
|
|
* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice including the dates of first publication and
|
|
|
|
* either this permission notice or a reference to
|
|
|
|
* http://oss.sgi.com/projects/FreeB/
|
|
|
|
* shall be included in all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*
|
|
|
|
* Except as contained in this notice, the name of Silicon Graphics, Inc.
|
|
|
|
* shall not be used in advertising or otherwise to promote the sale, use or
|
|
|
|
* other dealings in this Software without prior written authorization from
|
|
|
|
* Silicon Graphics, Inc.
|
|
|
|
*/
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
#include "packrender.h"
|
|
|
|
|
2004-11-03 18:55:31 +00:00
|
|
|
static const GLubyte MsbToLsbTable[256] = {
|
2008-10-13 13:32:52 +01:00
|
|
|
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
|
|
|
|
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
|
|
|
|
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
|
|
|
|
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
|
|
|
|
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
|
|
|
|
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
|
|
|
|
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
|
|
|
|
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
|
|
|
|
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
|
|
|
|
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
|
|
|
|
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
|
|
|
|
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
|
|
|
|
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
|
|
|
|
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
|
|
|
|
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
|
|
|
|
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
|
|
|
|
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
|
|
|
|
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
|
|
|
|
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
|
|
|
|
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
|
|
|
|
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
|
|
|
|
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
|
|
|
|
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
|
|
|
|
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
|
|
|
|
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
|
|
|
|
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
|
|
|
|
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
|
|
|
|
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
|
|
|
|
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
|
|
|
|
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
|
|
|
|
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
|
|
|
|
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
|
2004-10-25 22:09:16 +01:00
|
|
|
};
|
|
|
|
|
2004-11-03 18:55:31 +00:00
|
|
|
static const GLubyte LowBitsMask[9] = {
|
2008-10-13 13:32:52 +01:00
|
|
|
0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff,
|
2004-10-25 22:09:16 +01:00
|
|
|
};
|
|
|
|
|
2004-11-03 18:55:31 +00:00
|
|
|
static const GLubyte HighBitsMask[9] = {
|
2008-10-13 13:32:52 +01:00
|
|
|
0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff,
|
2004-10-25 22:09:16 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Copy bitmap data from clients packed memory applying unpacking modes as the
|
|
|
|
** data is transfered into the destImage buffer. Return in modes the
|
|
|
|
** set of pixel modes that are to be done by the server.
|
|
|
|
*/
|
2008-10-13 13:32:52 +01:00
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
FillBitmap(struct glx_context * gc, GLint width, GLint height,
|
2008-10-13 13:32:52 +01:00
|
|
|
GLenum format, const GLvoid * userdata, GLubyte * destImage)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:32:52 +01:00
|
|
|
const __GLXattribute *state = gc->client_state_private;
|
|
|
|
GLint rowLength = state->storeUnpack.rowLength;
|
|
|
|
GLint alignment = state->storeUnpack.alignment;
|
|
|
|
GLint skipPixels = state->storeUnpack.skipPixels;
|
|
|
|
GLint skipRows = state->storeUnpack.skipRows;
|
|
|
|
GLint lsbFirst = state->storeUnpack.lsbFirst;
|
|
|
|
GLint elementsLeft, bitOffset, currentByte, nextByte, highBitMask;
|
|
|
|
GLint lowBitMask, i;
|
|
|
|
GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
|
|
|
|
const GLubyte *start, *iter;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (rowLength > 0) {
|
|
|
|
groupsPerRow = rowLength;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
groupsPerRow = width;
|
|
|
|
}
|
|
|
|
components = __glElementsPerGroup(format, GL_BITMAP);
|
|
|
|
rowSize = (groupsPerRow * components + 7) >> 3;
|
|
|
|
padding = (rowSize % alignment);
|
|
|
|
if (padding) {
|
|
|
|
rowSize += alignment - padding;
|
|
|
|
}
|
|
|
|
start = ((const GLubyte *) userdata) + skipRows * rowSize +
|
|
|
|
((skipPixels * components) >> 3);
|
|
|
|
bitOffset = (skipPixels * components) & 7;
|
|
|
|
highBitMask = LowBitsMask[8 - bitOffset];
|
|
|
|
lowBitMask = HighBitsMask[bitOffset];
|
|
|
|
elementsPerRow = width * components;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
elementsLeft = elementsPerRow;
|
|
|
|
iter = start;
|
|
|
|
while (elementsLeft) {
|
|
|
|
/* First retrieve low bits from current byte */
|
|
|
|
if (lsbFirst) {
|
|
|
|
currentByte = MsbToLsbTable[iter[0]];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
currentByte = iter[0];
|
|
|
|
}
|
|
|
|
if (bitOffset) {
|
|
|
|
/* Need to read next byte to finish current byte */
|
|
|
|
if (elementsLeft > (8 - bitOffset)) {
|
|
|
|
if (lsbFirst) {
|
|
|
|
nextByte = MsbToLsbTable[iter[1]];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nextByte = iter[1];
|
|
|
|
}
|
|
|
|
currentByte =
|
|
|
|
((currentByte & highBitMask) << bitOffset) |
|
|
|
|
((nextByte & lowBitMask) >> (8 - bitOffset));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
currentByte = ((currentByte & highBitMask) << bitOffset);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (elementsLeft >= 8) {
|
|
|
|
*destImage = currentByte;
|
|
|
|
elementsLeft -= 8;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*destImage = currentByte & HighBitsMask[elementsLeft];
|
|
|
|
elementsLeft = 0;
|
|
|
|
}
|
|
|
|
destImage++;
|
|
|
|
iter++;
|
|
|
|
}
|
|
|
|
start += rowSize;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Extract array from user's data applying all pixel store modes.
|
|
|
|
** The internal packed array format used has LSB_FIRST = FALSE and
|
|
|
|
** ALIGNMENT = 1.
|
|
|
|
*/
|
2008-10-13 13:32:52 +01:00
|
|
|
void
|
2010-07-28 16:16:00 +01:00
|
|
|
__glFillImage(struct glx_context * gc, GLint dim, GLint width, GLint height,
|
2008-10-13 13:32:52 +01:00
|
|
|
GLint depth, GLenum format, GLenum type,
|
|
|
|
const GLvoid * userdata, GLubyte * newimage, GLubyte * modes)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:32:52 +01:00
|
|
|
const __GLXattribute *state = gc->client_state_private;
|
|
|
|
GLint rowLength = state->storeUnpack.rowLength;
|
|
|
|
GLint imageHeight = state->storeUnpack.imageHeight;
|
|
|
|
GLint alignment = state->storeUnpack.alignment;
|
|
|
|
GLint skipPixels = state->storeUnpack.skipPixels;
|
|
|
|
GLint skipRows = state->storeUnpack.skipRows;
|
|
|
|
GLint skipImages = state->storeUnpack.skipImages;
|
|
|
|
GLint swapBytes = state->storeUnpack.swapEndian;
|
|
|
|
GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
|
|
|
|
GLint elementsPerRow, imageSize, rowsPerImage, h, i, j, k;
|
|
|
|
const GLubyte *start, *iter, *itera, *iterb, *iterc;
|
|
|
|
GLubyte *iter2;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (type == GL_BITMAP) {
|
|
|
|
FillBitmap(gc, width, height, format, userdata, newimage);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
components = __glElementsPerGroup(format, type);
|
|
|
|
if (rowLength > 0) {
|
|
|
|
groupsPerRow = rowLength;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
groupsPerRow = width;
|
|
|
|
}
|
|
|
|
if (imageHeight > 0) {
|
|
|
|
rowsPerImage = imageHeight;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rowsPerImage = height;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
elementSize = __glBytesPerElement(type);
|
|
|
|
groupSize = elementSize * components;
|
|
|
|
if (elementSize == 1)
|
|
|
|
swapBytes = 0;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
rowSize = groupsPerRow * groupSize;
|
|
|
|
padding = (rowSize % alignment);
|
|
|
|
if (padding) {
|
|
|
|
rowSize += alignment - padding;
|
|
|
|
}
|
|
|
|
imageSize = rowSize * rowsPerImage;
|
|
|
|
start = ((const GLubyte *) userdata) + skipImages * imageSize +
|
|
|
|
skipRows * rowSize + skipPixels * groupSize;
|
|
|
|
iter2 = newimage;
|
|
|
|
elementsPerRow = width * components;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (swapBytes) {
|
|
|
|
itera = start;
|
|
|
|
for (h = 0; h < depth; h++) {
|
|
|
|
iterb = itera;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
iterc = iterb;
|
|
|
|
for (j = 0; j < elementsPerRow; j++) {
|
|
|
|
for (k = 1; k <= elementSize; k++) {
|
|
|
|
iter2[k - 1] = iterc[elementSize - k];
|
|
|
|
}
|
|
|
|
iter2 += elementSize;
|
|
|
|
iterc += elementSize;
|
|
|
|
}
|
|
|
|
iterb += rowSize;
|
|
|
|
}
|
|
|
|
itera += imageSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
itera = start;
|
|
|
|
for (h = 0; h < depth; h++) {
|
|
|
|
if (rowSize == elementsPerRow * elementSize) {
|
|
|
|
/* Ha! This is mondo easy! */
|
|
|
|
__GLX_MEM_COPY(iter2, itera,
|
|
|
|
elementsPerRow * elementSize * height);
|
|
|
|
iter2 += elementsPerRow * elementSize * height;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
iter = itera;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
__GLX_MEM_COPY(iter2, iter, elementsPerRow * elementSize);
|
|
|
|
iter2 += elementsPerRow * elementSize;
|
|
|
|
iter += rowSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
itera += imageSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
/* Setup store modes that describe what we just did */
|
|
|
|
if (modes) {
|
|
|
|
if (dim < 3) {
|
|
|
|
(void) memcpy(modes, __glXDefaultPixelStore + 4, 20);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
(void) memcpy(modes, __glXDefaultPixelStore + 0, 36);
|
|
|
|
}
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Empty a bitmap in LSB_FIRST=GL_FALSE and ALIGNMENT=4 format packing it
|
|
|
|
** into the clients memory using the pixel store PACK modes.
|
|
|
|
*/
|
2008-10-13 13:32:52 +01:00
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
EmptyBitmap(struct glx_context * gc, GLint width, GLint height,
|
2008-10-13 13:32:52 +01:00
|
|
|
GLenum format, const GLubyte * sourceImage, GLvoid * userdata)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:32:52 +01:00
|
|
|
const __GLXattribute *state = gc->client_state_private;
|
|
|
|
GLint rowLength = state->storePack.rowLength;
|
|
|
|
GLint alignment = state->storePack.alignment;
|
|
|
|
GLint skipPixels = state->storePack.skipPixels;
|
|
|
|
GLint skipRows = state->storePack.skipRows;
|
|
|
|
GLint lsbFirst = state->storePack.lsbFirst;
|
|
|
|
GLint components, groupsPerRow, rowSize, padding, elementsPerRow;
|
|
|
|
GLint sourceRowSize, sourcePadding, sourceSkip;
|
|
|
|
GLubyte *start, *iter;
|
|
|
|
GLint elementsLeft, bitOffset, currentByte, highBitMask, lowBitMask;
|
|
|
|
GLint writeMask, i;
|
|
|
|
GLubyte writeByte;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
components = __glElementsPerGroup(format, GL_BITMAP);
|
|
|
|
if (rowLength > 0) {
|
|
|
|
groupsPerRow = rowLength;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
groupsPerRow = width;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
rowSize = (groupsPerRow * components + 7) >> 3;
|
|
|
|
padding = (rowSize % alignment);
|
|
|
|
if (padding) {
|
|
|
|
rowSize += alignment - padding;
|
|
|
|
}
|
|
|
|
sourceRowSize = (width * components + 7) >> 3;
|
|
|
|
sourcePadding = (sourceRowSize % 4);
|
|
|
|
if (sourcePadding) {
|
|
|
|
sourceSkip = 4 - sourcePadding;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
sourceSkip = 0;
|
|
|
|
}
|
|
|
|
start = ((GLubyte *) userdata) + skipRows * rowSize +
|
|
|
|
((skipPixels * components) >> 3);
|
|
|
|
bitOffset = (skipPixels * components) & 7;
|
|
|
|
highBitMask = LowBitsMask[8 - bitOffset];
|
|
|
|
lowBitMask = HighBitsMask[bitOffset];
|
|
|
|
elementsPerRow = width * components;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
elementsLeft = elementsPerRow;
|
|
|
|
iter = start;
|
|
|
|
writeMask = highBitMask;
|
|
|
|
writeByte = 0;
|
|
|
|
while (elementsLeft) {
|
|
|
|
/* Set up writeMask (to write to current byte) */
|
|
|
|
if (elementsLeft + bitOffset < 8) {
|
|
|
|
/* Need to trim writeMask */
|
|
|
|
writeMask &= HighBitsMask[bitOffset + elementsLeft];
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (lsbFirst) {
|
|
|
|
currentByte = MsbToLsbTable[iter[0]];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
currentByte = iter[0];
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (bitOffset) {
|
|
|
|
writeByte |= (sourceImage[0] >> bitOffset);
|
|
|
|
currentByte = (currentByte & ~writeMask) |
|
|
|
|
(writeByte & writeMask);
|
|
|
|
writeByte = (sourceImage[0] << (8 - bitOffset));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
currentByte = (currentByte & ~writeMask) |
|
|
|
|
(sourceImage[0] & writeMask);
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (lsbFirst) {
|
|
|
|
iter[0] = MsbToLsbTable[currentByte];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
iter[0] = currentByte;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (elementsLeft >= 8) {
|
|
|
|
elementsLeft -= 8;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
elementsLeft = 0;
|
|
|
|
}
|
|
|
|
sourceImage++;
|
|
|
|
iter++;
|
|
|
|
writeMask = 0xff;
|
|
|
|
}
|
|
|
|
if (writeByte) {
|
|
|
|
/* Some data left over that still needs writing */
|
|
|
|
writeMask &= lowBitMask;
|
|
|
|
if (lsbFirst) {
|
|
|
|
currentByte = MsbToLsbTable[iter[0]];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
currentByte = iter[0];
|
|
|
|
}
|
|
|
|
currentByte = (currentByte & ~writeMask) | (writeByte & writeMask);
|
|
|
|
if (lsbFirst) {
|
|
|
|
iter[0] = MsbToLsbTable[currentByte];
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
iter[0] = currentByte;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
start += rowSize;
|
|
|
|
sourceImage += sourceSkip;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Insert array into user's data applying all pixel store modes.
|
|
|
|
** The packed array format from the server is LSB_FIRST = FALSE,
|
|
|
|
** SWAP_BYTES = the current pixel storage pack mode, and ALIGNMENT = 4.
|
|
|
|
** Named __glEmptyImage() because it is the opposite of __glFillImage().
|
|
|
|
*/
|
|
|
|
/* ARGSUSED */
|
2008-10-13 13:32:52 +01:00
|
|
|
void
|
2010-07-28 16:16:00 +01:00
|
|
|
__glEmptyImage(struct glx_context * gc, GLint dim, GLint width, GLint height,
|
2008-10-13 13:32:52 +01:00
|
|
|
GLint depth, GLenum format, GLenum type,
|
|
|
|
const GLubyte * sourceImage, GLvoid * userdata)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2008-10-13 13:32:52 +01:00
|
|
|
const __GLXattribute *state = gc->client_state_private;
|
|
|
|
GLint rowLength = state->storePack.rowLength;
|
|
|
|
GLint imageHeight = state->storePack.imageHeight;
|
|
|
|
GLint alignment = state->storePack.alignment;
|
|
|
|
GLint skipPixels = state->storePack.skipPixels;
|
|
|
|
GLint skipRows = state->storePack.skipRows;
|
|
|
|
GLint skipImages = state->storePack.skipImages;
|
|
|
|
GLint components, elementSize, rowSize, padding, groupsPerRow, groupSize;
|
|
|
|
GLint elementsPerRow, sourceRowSize, sourcePadding, h, i;
|
|
|
|
GLint imageSize, rowsPerImage;
|
|
|
|
GLubyte *start, *iter, *itera;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
if (type == GL_BITMAP) {
|
|
|
|
EmptyBitmap(gc, width, height, format, sourceImage, userdata);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
components = __glElementsPerGroup(format, type);
|
|
|
|
if (rowLength > 0) {
|
|
|
|
groupsPerRow = rowLength;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
groupsPerRow = width;
|
|
|
|
}
|
|
|
|
if (imageHeight > 0) {
|
|
|
|
rowsPerImage = imageHeight;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rowsPerImage = height;
|
|
|
|
}
|
|
|
|
elementSize = __glBytesPerElement(type);
|
|
|
|
groupSize = elementSize * components;
|
|
|
|
rowSize = groupsPerRow * groupSize;
|
|
|
|
padding = (rowSize % alignment);
|
|
|
|
if (padding) {
|
|
|
|
rowSize += alignment - padding;
|
|
|
|
}
|
|
|
|
sourceRowSize = width * groupSize;
|
|
|
|
sourcePadding = (sourceRowSize % 4);
|
|
|
|
if (sourcePadding) {
|
|
|
|
sourceRowSize += 4 - sourcePadding;
|
|
|
|
}
|
|
|
|
imageSize = sourceRowSize * rowsPerImage;
|
|
|
|
start = ((GLubyte *) userdata) + skipImages * imageSize +
|
|
|
|
skipRows * rowSize + skipPixels * groupSize;
|
|
|
|
elementsPerRow = width * components;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:32:52 +01:00
|
|
|
itera = start;
|
|
|
|
for (h = 0; h < depth; h++) {
|
|
|
|
if ((rowSize == sourceRowSize) && (sourcePadding == 0)) {
|
|
|
|
/* Ha! This is mondo easy! */
|
|
|
|
__GLX_MEM_COPY(itera, sourceImage,
|
|
|
|
elementsPerRow * elementSize * height);
|
|
|
|
sourceImage += elementsPerRow * elementSize * height;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
iter = itera;
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
__GLX_MEM_COPY(iter, sourceImage,
|
|
|
|
elementsPerRow * elementSize);
|
|
|
|
sourceImage += sourceRowSize;
|
|
|
|
iter += rowSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
itera += imageSize;
|
|
|
|
}
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|