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.
|
|
|
|
*
|
2022-12-14 18:27:16 +00:00
|
|
|
* SPDX-License-Identifier: SGI-B-2.0
|
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
|
|
|
*/
|
2004-10-25 22:09:16 +01:00
|
|
|
|
|
|
|
#include "glxclient.h"
|
2005-04-14 21:35:33 +01:00
|
|
|
#include "indirect.h"
|
2015-07-13 02:05:58 +01:00
|
|
|
#include "util/rounding.h"
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2010-03-04 00:02:45 +00:00
|
|
|
#if !defined(__GNUC__)
|
2009-03-24 03:35:09 +00:00
|
|
|
# define __builtin_expect(x, y) x
|
|
|
|
#endif
|
|
|
|
|
2005-04-18 17:40:36 +01:00
|
|
|
/**
|
|
|
|
* Send glPixelStore command to the server
|
|
|
|
*
|
|
|
|
* \param gc Current GLX context
|
|
|
|
* \param sop Either \c X_GLsop_PixelStoref or \c X_GLsop_PixelStorei
|
|
|
|
* \param pname Selector of which pixel parameter is to be set.
|
|
|
|
* \param param Value that \c pname is set to.
|
|
|
|
*
|
|
|
|
* \sa __indirect_glPixelStorei, __indirect_glPixelStoref
|
|
|
|
*/
|
|
|
|
static void
|
2010-07-28 16:16:00 +01:00
|
|
|
send_PixelStore(struct glx_context * gc, unsigned sop, GLenum pname,
|
2008-10-13 13:33:28 +01:00
|
|
|
const void *param)
|
2005-04-18 17:40:36 +01:00
|
|
|
{
|
2008-10-13 13:33:28 +01:00
|
|
|
Display *const dpy = gc->currentDpy;
|
|
|
|
const GLuint cmdlen = 8;
|
|
|
|
if (__builtin_expect(dpy != NULL, 1)) {
|
|
|
|
GLubyte const *pc = __glXSetupSingleRequest(gc, sop, cmdlen);
|
|
|
|
(void) memcpy((void *) (pc + 0), (void *) (&pname), 4);
|
|
|
|
(void) memcpy((void *) (pc + 4), param, 4);
|
|
|
|
UnlockDisplay(dpy);
|
|
|
|
SyncHandle();
|
|
|
|
}
|
|
|
|
return;
|
2005-04-18 17:40:36 +01:00
|
|
|
}
|
|
|
|
|
2004-10-25 22:09:16 +01:00
|
|
|
/*
|
|
|
|
** Specify parameters that control the storage format of pixel arrays.
|
|
|
|
*/
|
2008-10-13 13:33:28 +01:00
|
|
|
void
|
|
|
|
__indirect_glPixelStoref(GLenum pname, GLfloat param)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_context *gc = __glXGetCurrentContext();
|
2008-10-13 13:33:28 +01:00
|
|
|
__GLXattribute *state = gc->client_state_private;
|
|
|
|
Display *dpy = gc->currentDpy;
|
|
|
|
GLuint a;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
if (!dpy)
|
|
|
|
return;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
switch (pname) {
|
|
|
|
case GL_PACK_ROW_LENGTH:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.rowLength = a;
|
|
|
|
break;
|
|
|
|
case GL_PACK_IMAGE_HEIGHT:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.imageHeight = a;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_ROWS:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipRows = a;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_PIXELS:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipPixels = a;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_IMAGES:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipImages = a;
|
|
|
|
break;
|
|
|
|
case GL_PACK_ALIGNMENT:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
switch (a) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
|
|
|
state->storePack.alignment = a;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GL_PACK_SWAP_BYTES:
|
|
|
|
state->storePack.swapEndian = (param != 0);
|
|
|
|
break;
|
|
|
|
case GL_PACK_LSB_FIRST:
|
|
|
|
state->storePack.lsbFirst = (param != 0);
|
|
|
|
break;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
case GL_UNPACK_ROW_LENGTH:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.rowLength = a;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_IMAGE_HEIGHT:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.imageHeight = a;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_ROWS:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipRows = a;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_PIXELS:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipPixels = a;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_IMAGES:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
if (((GLint) a) < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipImages = a;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_ALIGNMENT:
|
2015-07-13 02:05:58 +01:00
|
|
|
a = _mesa_lroundevenf(param);
|
2008-10-13 13:33:28 +01:00
|
|
|
switch (a) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
|
|
|
state->storeUnpack.alignment = a;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SWAP_BYTES:
|
|
|
|
state->storeUnpack.swapEndian = (param != 0);
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_LSB_FIRST:
|
|
|
|
state->storeUnpack.lsbFirst = (param != 0);
|
|
|
|
break;
|
2005-04-18 17:40:36 +01:00
|
|
|
|
|
|
|
/* Group all of the pixel store modes that need to be sent to the
|
|
|
|
* server here. Care must be used to only send modes to the server that
|
|
|
|
* won't affect the size of the data sent to or received from the
|
|
|
|
* server. GL_PACK_INVERT_MESA is safe in this respect, but other,
|
|
|
|
* future modes may not be.
|
|
|
|
*/
|
2008-10-13 13:33:28 +01:00
|
|
|
case GL_PACK_INVERT_MESA:
|
|
|
|
send_PixelStore(gc, X_GLsop_PixelStoref, pname, ¶m);
|
|
|
|
break;
|
2005-04-18 17:40:36 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
break;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
void
|
|
|
|
__indirect_glPixelStorei(GLenum pname, GLint param)
|
2004-10-25 22:09:16 +01:00
|
|
|
{
|
2010-07-28 16:16:00 +01:00
|
|
|
struct glx_context *gc = __glXGetCurrentContext();
|
2008-10-13 13:33:28 +01:00
|
|
|
__GLXattribute *state = gc->client_state_private;
|
|
|
|
Display *dpy = gc->currentDpy;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
if (!dpy)
|
|
|
|
return;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
switch (pname) {
|
|
|
|
case GL_PACK_ROW_LENGTH:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.rowLength = param;
|
|
|
|
break;
|
|
|
|
case GL_PACK_IMAGE_HEIGHT:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.imageHeight = param;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_ROWS:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipRows = param;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_PIXELS:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipPixels = param;
|
|
|
|
break;
|
|
|
|
case GL_PACK_SKIP_IMAGES:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storePack.skipImages = param;
|
|
|
|
break;
|
|
|
|
case GL_PACK_ALIGNMENT:
|
|
|
|
switch (param) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
|
|
|
state->storePack.alignment = param;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GL_PACK_SWAP_BYTES:
|
|
|
|
state->storePack.swapEndian = (param != 0);
|
|
|
|
break;
|
|
|
|
case GL_PACK_LSB_FIRST:
|
|
|
|
state->storePack.lsbFirst = (param != 0);
|
|
|
|
break;
|
2004-10-25 22:09:16 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
case GL_UNPACK_ROW_LENGTH:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.rowLength = param;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_IMAGE_HEIGHT:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.imageHeight = param;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_ROWS:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipRows = param;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_PIXELS:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipPixels = param;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SKIP_IMAGES:
|
|
|
|
if (param < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
state->storeUnpack.skipImages = param;
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_ALIGNMENT:
|
|
|
|
switch (param) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
case 4:
|
|
|
|
case 8:
|
|
|
|
state->storeUnpack.alignment = param;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_SWAP_BYTES:
|
|
|
|
state->storeUnpack.swapEndian = (param != 0);
|
|
|
|
break;
|
|
|
|
case GL_UNPACK_LSB_FIRST:
|
|
|
|
state->storeUnpack.lsbFirst = (param != 0);
|
|
|
|
break;
|
2005-04-18 17:40:36 +01:00
|
|
|
|
|
|
|
/* Group all of the pixel store modes that need to be sent to the
|
|
|
|
* server here. Care must be used to only send modes to the server that
|
|
|
|
* won't affect the size of the data sent to or received from the
|
|
|
|
* server. GL_PACK_INVERT_MESA is safe in this respect, but other,
|
|
|
|
* future modes may not be.
|
|
|
|
*/
|
2008-10-13 13:33:28 +01:00
|
|
|
case GL_PACK_INVERT_MESA:
|
|
|
|
send_PixelStore(gc, X_GLsop_PixelStorei, pname, ¶m);
|
|
|
|
break;
|
2005-04-18 17:40:36 +01:00
|
|
|
|
2008-10-13 13:33:28 +01:00
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
break;
|
|
|
|
}
|
2004-10-25 22:09:16 +01:00
|
|
|
}
|