[deb_xorg-server.git] / hw / dmx / glxProxy / renderpixswap.c

/*
 * 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.
 */

#include "glxserver.h"
#include "unpack.h"
#include "g_disptab.h"

void
__glXDispSwap_PolygonStipple(GLbyte * pc)
{
    __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_Bitmap(GLbyte * pc)
{
    __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_FLOAT((GLbyte *) &hdr->xorig);
    __GLX_SWAP_FLOAT((GLbyte *) &hdr->yorig);
    __GLX_SWAP_FLOAT((GLbyte *) &hdr->xmove);
    __GLX_SWAP_FLOAT((GLbyte *) &hdr->ymove);

    hdr->swapBytes = !hdr->swapBytes;

}

void
__glXDispSwap_TexImage1D(GLbyte * pc)
{
    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->components);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->border);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_TexImage2D(GLbyte * pc)
{
    __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->components);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->border);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_TexImage3D(GLbyte * pc)
{
    __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
    __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->depth);
    __GLX_SWAP_INT((GLbyte *) &hdr->size4d);
    __GLX_SWAP_INT((GLbyte *) &hdr->border);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_DrawPixels(GLbyte * pc)
{
    __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_TexSubImage1D(GLbyte * pc)
{
    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_TexSubImage2D(GLbyte * pc)
{
    __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_TexSubImage3D(GLbyte * pc)
{
    __GLXdispatchTexSubImage3DHeader *hdr =
        (__GLXdispatchTexSubImage3DHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
    __GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->level);
    __GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->zoffset);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->depth);
    __GLX_SWAP_INT((GLbyte *) &hdr->size4d);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_ColorTable(GLbyte * pc)
{
    __GLXdispatchColorTableHeader *hdr = (__GLXdispatchColorTableHeader *) pc;

    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_ColorSubTable(GLbyte * pc)
{
    __GLXdispatchColorSubTableHeader *hdr =
        (__GLXdispatchColorSubTableHeader *) pc;
    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->start);
    __GLX_SWAP_INT((GLbyte *) &hdr->count);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
{
    __GLXdispatchConvolutionFilterHeader *hdr =
        (__GLXdispatchConvolutionFilterHeader *) pc;
    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
{
    __GLXdispatchConvolutionFilterHeader *hdr =
        (__GLXdispatchConvolutionFilterHeader *) pc;
    __GLX_DECLARE_SWAP_VARIABLES;

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}

void
__glXDispSwap_SeparableFilter2D(GLbyte * pc)
{
    __GLXdispatchConvolutionFilterHeader *hdr =
        (__GLXdispatchConvolutionFilterHeader *) pc;
    GLint hdrlen;

    __GLX_DECLARE_SWAP_VARIABLES;

    hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);

    __GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
    __GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
    __GLX_SWAP_INT((GLbyte *) &hdr->alignment);

    __GLX_SWAP_INT((GLbyte *) &hdr->target);
    __GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
    __GLX_SWAP_INT((GLbyte *) &hdr->width);
    __GLX_SWAP_INT((GLbyte *) &hdr->height);
    __GLX_SWAP_INT((GLbyte *) &hdr->format);
    __GLX_SWAP_INT((GLbyte *) &hdr->type);

    /*
     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
     ** the pixel data.
     */
    hdr->swapBytes = !hdr->swapBytes;
}
Commit	Line	Data
a09e091a JB	1	/*
	2	* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
	3	* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a
	6	* copy of this software and associated documentation files (the "Software"),
	7	* to deal in the Software without restriction, including without limitation
	8	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	9	* and/or sell copies of the Software, and to permit persons to whom the
	10	* Software is furnished to do so, subject to the following conditions:
	11	*
	12	* The above copyright notice including the dates of first publication and
	13	* either this permission notice or a reference to
	14	* http://oss.sgi.com/projects/FreeB/
	15	* shall be included 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	* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	21	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
	22	* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	23	* SOFTWARE.
	24	*
	25	* Except as contained in this notice, the name of Silicon Graphics, Inc.
	26	* shall not be used in advertising or otherwise to promote the sale, use or
	27	* other dealings in this Software without prior written authorization from
	28	* Silicon Graphics, Inc.
	29	*/
	30
	31	#include "glxserver.h"
	32	#include "unpack.h"
	33	#include "g_disptab.h"
	34
	35	void
	36	__glXDispSwap_PolygonStipple(GLbyte * pc)
	37	{
	38	__GLXpixelHeader hdr = (__GLXpixelHeader ) pc;
	39
	40	__GLX_DECLARE_SWAP_VARIABLES;
	41
	42	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
	43	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
	44	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
	45	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
	46
	47	hdr->swapBytes = !hdr->swapBytes;
	48	}
	49
	50	void
	51	__glXDispSwap_Bitmap(GLbyte * pc)
	52	{
	53	__GLXdispatchBitmapHeader hdr = (__GLXdispatchBitmapHeader ) pc;
	54
	55	__GLX_DECLARE_SWAP_VARIABLES;
	56
	57	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
	58	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
	59	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
	60	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
	61
	62	__GLX_SWAP_INT((GLbyte *) &hdr->width);
	63	__GLX_SWAP_INT((GLbyte *) &hdr->height);
	64	__GLX_SWAP_FLOAT((GLbyte *) &hdr->xorig);
65	__GLX_SWAP_FLOAT((GLbyte *) &hdr->yorig);
66	__GLX_SWAP_FLOAT((GLbyte *) &hdr->xmove);
67	__GLX_SWAP_FLOAT((GLbyte *) &hdr->ymove);
68
69	hdr->swapBytes = !hdr->swapBytes;
70
71	}
72
73	void
74	__glXDispSwap_TexImage1D(GLbyte * pc)
75	{
76	__GLXdispatchTexImageHeader hdr = (__GLXdispatchTexImageHeader ) pc;
77
78	__GLX_DECLARE_SWAP_VARIABLES;
79
80	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
81	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
82	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
83	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
84
85	__GLX_SWAP_INT((GLbyte *) &hdr->target);
86	__GLX_SWAP_INT((GLbyte *) &hdr->level);
87	__GLX_SWAP_INT((GLbyte *) &hdr->components);
88	__GLX_SWAP_INT((GLbyte *) &hdr->width);
89	__GLX_SWAP_INT((GLbyte *) &hdr->height);
90	__GLX_SWAP_INT((GLbyte *) &hdr->border);
91	__GLX_SWAP_INT((GLbyte *) &hdr->format);
92	__GLX_SWAP_INT((GLbyte *) &hdr->type);
93
94	/*
95	** Just invert swapBytes flag; the GL will figure out if it needs to swap
96	** the pixel data.
97	*/
98	hdr->swapBytes = !hdr->swapBytes;
99	}
100
101	void
102	__glXDispSwap_TexImage2D(GLbyte * pc)
103	{
104	__GLXdispatchTexImageHeader hdr = (__GLXdispatchTexImageHeader ) pc;
105
106	__GLX_DECLARE_SWAP_VARIABLES;
107
108	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
109	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
110	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
111	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
112
113	__GLX_SWAP_INT((GLbyte *) &hdr->target);
114	__GLX_SWAP_INT((GLbyte *) &hdr->level);
115	__GLX_SWAP_INT((GLbyte *) &hdr->components);
116	__GLX_SWAP_INT((GLbyte *) &hdr->width);
117	__GLX_SWAP_INT((GLbyte *) &hdr->height);
118	__GLX_SWAP_INT((GLbyte *) &hdr->border);
119	__GLX_SWAP_INT((GLbyte *) &hdr->format);
120	__GLX_SWAP_INT((GLbyte *) &hdr->type);
121
122	/*
123	** Just invert swapBytes flag; the GL will figure out if it needs to swap
124	** the pixel data.
125	*/
126	hdr->swapBytes = !hdr->swapBytes;
127	}
128
129	void
130	__glXDispSwap_TexImage3D(GLbyte * pc)
131	{
132	__GLXdispatchTexImage3DHeader hdr = (__GLXdispatchTexImage3DHeader ) pc;
133
134	__GLX_DECLARE_SWAP_VARIABLES;
135
136	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
137	__GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
138	__GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
139	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
140	__GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
141	__GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
142	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
143	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
144
145	__GLX_SWAP_INT((GLbyte *) &hdr->target);
146	__GLX_SWAP_INT((GLbyte *) &hdr->level);
147	__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
148	__GLX_SWAP_INT((GLbyte *) &hdr->width);
149	__GLX_SWAP_INT((GLbyte *) &hdr->height);
150	__GLX_SWAP_INT((GLbyte *) &hdr->depth);
151	__GLX_SWAP_INT((GLbyte *) &hdr->size4d);
152	__GLX_SWAP_INT((GLbyte *) &hdr->border);
153	__GLX_SWAP_INT((GLbyte *) &hdr->format);
154	__GLX_SWAP_INT((GLbyte *) &hdr->type);
155
156	/*
157	** Just invert swapBytes flag; the GL will figure out if it needs to swap
158	** the pixel data.
159	*/
160	hdr->swapBytes = !hdr->swapBytes;
161	}
162
163	void
164	__glXDispSwap_DrawPixels(GLbyte * pc)
165	{
166	__GLXdispatchDrawPixelsHeader hdr = (__GLXdispatchDrawPixelsHeader ) pc;
167
168	__GLX_DECLARE_SWAP_VARIABLES;
169
170	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
171	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
172	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
173	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
174
175	__GLX_SWAP_INT((GLbyte *) &hdr->width);
176	__GLX_SWAP_INT((GLbyte *) &hdr->height);
177	__GLX_SWAP_INT((GLbyte *) &hdr->format);
178	__GLX_SWAP_INT((GLbyte *) &hdr->type);
179
180	/*
181	** Just invert swapBytes flag; the GL will figure out if it needs to swap
182	** the pixel data.
183	*/
184	hdr->swapBytes = !hdr->swapBytes;
185	}
186
187	void
188	__glXDispSwap_TexSubImage1D(GLbyte * pc)
189	{
190	__GLXdispatchTexSubImageHeader hdr = (__GLXdispatchTexSubImageHeader ) pc;
191
192	__GLX_DECLARE_SWAP_VARIABLES;
193
194	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
195	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
196	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
197	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
198
199	__GLX_SWAP_INT((GLbyte *) &hdr->target);
200	__GLX_SWAP_INT((GLbyte *) &hdr->level);
201	__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
202	__GLX_SWAP_INT((GLbyte *) &hdr->width);
203	__GLX_SWAP_INT((GLbyte *) &hdr->format);
204	__GLX_SWAP_INT((GLbyte *) &hdr->type);
205
206	/*
207	** Just invert swapBytes flag; the GL will figure out if it needs to swap
208	** the pixel data.
209	*/
210	hdr->swapBytes = !hdr->swapBytes;
211	}
212
213	void
214	__glXDispSwap_TexSubImage2D(GLbyte * pc)
215	{
216	__GLXdispatchTexSubImageHeader hdr = (__GLXdispatchTexSubImageHeader ) pc;
217
218	__GLX_DECLARE_SWAP_VARIABLES;
219
220	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
221	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
222	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
223	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
224
225	__GLX_SWAP_INT((GLbyte *) &hdr->target);
226	__GLX_SWAP_INT((GLbyte *) &hdr->level);
227	__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
228	__GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
229	__GLX_SWAP_INT((GLbyte *) &hdr->width);
230	__GLX_SWAP_INT((GLbyte *) &hdr->height);
231	__GLX_SWAP_INT((GLbyte *) &hdr->format);
232	__GLX_SWAP_INT((GLbyte *) &hdr->type);
233
234	/*
235	** Just invert swapBytes flag; the GL will figure out if it needs to swap
236	** the pixel data.
237	*/
238	hdr->swapBytes = !hdr->swapBytes;
239	}
240
241	void
242	__glXDispSwap_TexSubImage3D(GLbyte * pc)
243	{
244	__GLXdispatchTexSubImage3DHeader *hdr =
245	(__GLXdispatchTexSubImage3DHeader *) pc;
246
247	__GLX_DECLARE_SWAP_VARIABLES;
248
249	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
250	__GLX_SWAP_INT((GLbyte *) &hdr->imageHeight);
251	__GLX_SWAP_INT((GLbyte *) &hdr->imageDepth);
252	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
253	__GLX_SWAP_INT((GLbyte *) &hdr->skipImages);
254	__GLX_SWAP_INT((GLbyte *) &hdr->skipVolumes);
255	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
256	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
257
258	__GLX_SWAP_INT((GLbyte *) &hdr->target);
259	__GLX_SWAP_INT((GLbyte *) &hdr->level);
260	__GLX_SWAP_INT((GLbyte *) &hdr->xoffset);
261	__GLX_SWAP_INT((GLbyte *) &hdr->yoffset);
262	__GLX_SWAP_INT((GLbyte *) &hdr->zoffset);
263	__GLX_SWAP_INT((GLbyte *) &hdr->width);
264	__GLX_SWAP_INT((GLbyte *) &hdr->height);
265	__GLX_SWAP_INT((GLbyte *) &hdr->depth);
266	__GLX_SWAP_INT((GLbyte *) &hdr->size4d);
267	__GLX_SWAP_INT((GLbyte *) &hdr->format);
268	__GLX_SWAP_INT((GLbyte *) &hdr->type);
269
270	/*
271	** Just invert swapBytes flag; the GL will figure out if it needs to swap
272	** the pixel data.
273	*/
274	hdr->swapBytes = !hdr->swapBytes;
275	}
276
277	void
278	__glXDispSwap_ColorTable(GLbyte * pc)
279	{
280	__GLXdispatchColorTableHeader hdr = (__GLXdispatchColorTableHeader ) pc;
281
282	__GLX_DECLARE_SWAP_VARIABLES;
283
284	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
285	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
286	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
287	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
288
289	__GLX_SWAP_INT((GLbyte *) &hdr->target);
290	__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
291	__GLX_SWAP_INT((GLbyte *) &hdr->width);
292	__GLX_SWAP_INT((GLbyte *) &hdr->format);
293	__GLX_SWAP_INT((GLbyte *) &hdr->type);
294
295	/*
296	** Just invert swapBytes flag; the GL will figure out if it needs to swap
297	** the pixel data.
298	*/
299	hdr->swapBytes = !hdr->swapBytes;
300	}
301
302	void
303	__glXDispSwap_ColorSubTable(GLbyte * pc)
304	{
305	__GLXdispatchColorSubTableHeader *hdr =
306	(__GLXdispatchColorSubTableHeader *) pc;
307	__GLX_DECLARE_SWAP_VARIABLES;
308
309	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
310	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
311	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
312	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
313
314	__GLX_SWAP_INT((GLbyte *) &hdr->target);
315	__GLX_SWAP_INT((GLbyte *) &hdr->start);
316	__GLX_SWAP_INT((GLbyte *) &hdr->count);
317	__GLX_SWAP_INT((GLbyte *) &hdr->format);
318	__GLX_SWAP_INT((GLbyte *) &hdr->type);
319
320	/*
321	** Just invert swapBytes flag; the GL will figure out if it needs to swap
322	** the pixel data.
323	*/
324	hdr->swapBytes = !hdr->swapBytes;
325	}
326
327	void
328	__glXDispSwap_ConvolutionFilter1D(GLbyte * pc)
329	{
330	__GLXdispatchConvolutionFilterHeader *hdr =
331	(__GLXdispatchConvolutionFilterHeader *) pc;
332	__GLX_DECLARE_SWAP_VARIABLES;
333
334	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
335	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
336	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
337	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
338
339	__GLX_SWAP_INT((GLbyte *) &hdr->target);
340	__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
341	__GLX_SWAP_INT((GLbyte *) &hdr->width);
342	__GLX_SWAP_INT((GLbyte *) &hdr->format);
343	__GLX_SWAP_INT((GLbyte *) &hdr->type);
344
345	/*
346	** Just invert swapBytes flag; the GL will figure out if it needs to swap
347	** the pixel data.
348	*/
349	hdr->swapBytes = !hdr->swapBytes;
350	}
351
352	void
353	__glXDispSwap_ConvolutionFilter2D(GLbyte * pc)
354	{
355	__GLXdispatchConvolutionFilterHeader *hdr =
356	(__GLXdispatchConvolutionFilterHeader *) pc;
357	__GLX_DECLARE_SWAP_VARIABLES;
358
359	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
360	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
361	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
362	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
363
364	__GLX_SWAP_INT((GLbyte *) &hdr->target);
365	__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
366	__GLX_SWAP_INT((GLbyte *) &hdr->width);
367	__GLX_SWAP_INT((GLbyte *) &hdr->height);
368	__GLX_SWAP_INT((GLbyte *) &hdr->format);
369	__GLX_SWAP_INT((GLbyte *) &hdr->type);
370
371	/*
372	** Just invert swapBytes flag; the GL will figure out if it needs to swap
373	** the pixel data.
374	*/
375	hdr->swapBytes = !hdr->swapBytes;
376	}
377
378	void
379	__glXDispSwap_SeparableFilter2D(GLbyte * pc)
380	{
381	__GLXdispatchConvolutionFilterHeader *hdr =
382	(__GLXdispatchConvolutionFilterHeader *) pc;
383	GLint hdrlen;
384
385	__GLX_DECLARE_SWAP_VARIABLES;
386
387	hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
388
389	__GLX_SWAP_INT((GLbyte *) &hdr->rowLength);
390	__GLX_SWAP_INT((GLbyte *) &hdr->skipRows);
391	__GLX_SWAP_INT((GLbyte *) &hdr->skipPixels);
392	__GLX_SWAP_INT((GLbyte *) &hdr->alignment);
393
394	__GLX_SWAP_INT((GLbyte *) &hdr->target);
395	__GLX_SWAP_INT((GLbyte *) &hdr->internalformat);
396	__GLX_SWAP_INT((GLbyte *) &hdr->width);
397	__GLX_SWAP_INT((GLbyte *) &hdr->height);
398	__GLX_SWAP_INT((GLbyte *) &hdr->format);
399	__GLX_SWAP_INT((GLbyte *) &hdr->type);
400
401	/*
402	** Just invert swapBytes flag; the GL will figure out if it needs to swap
403	** the pixel data.
404	*/
405	hdr->swapBytes = !hdr->swapBytes;
406	}