xorg-server-1.4/hw/dmx/glxProxy/renderpixswap.c

   1 /*
   2 ** License Applicability. Except to the extent portions of this file are
   3 ** made subject to an alternative license as permitted in the SGI Free
   4 ** Software License B, Version 1.1 (the "License"), the contents of this
   5 ** file are subject only to the provisions of the License. You may not use
   6 ** this file except in compliance with the License. You may obtain a copy
   7 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
   8 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
   9 **
  10 ** http://oss.sgi.com/projects/FreeB
  11 **
  12 ** Note that, as provided in the License, the Software is distributed on an
  13 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
  14 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
  15 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
  16 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
  17 **
  18 ** Original Code. The Original Code is: OpenGL Sample Implementation,
  19 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
  20 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
  21 ** Copyright in any portions created by third parties is as indicated
  22 ** elsewhere herein. All Rights Reserved.
  23 **
  24 ** Additional Notice Provisions: The application programming interfaces
  25 ** established by SGI in conjunction with the Original Code are The
  26 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
  27 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
  28 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
  29 ** Window System(R) (Version 1.3), released October 19, 1998. This software
  30 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
  31 ** published by SGI, but has not been independently verified as being
  32 ** compliant with the OpenGL(R) version 1.2.1 Specification.
  33 **
  34 */
  35
  36 #define NEED_REPLIES
  37 #include "glxserver.h"
  38 #include "unpack.h"
  39 #include "g_disptab.h"
  40
  41 void __glXDispSwap_PolygonStipple(GLbyte *pc)
  42 {
  43     __GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
  44     __GLX_DECLARE_SWAP_VARIABLES;
  45
  46     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
  47     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
  48     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
  49     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
  50
  51     hdr->swapBytes = !hdr->swapBytes;
  52 }
  53
  54 void __glXDispSwap_Bitmap(GLbyte *pc)
  55 {
  56     __GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
  57     __GLX_DECLARE_SWAP_VARIABLES;
  58
  59     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
  60     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
  61     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
  62     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
  63
  64     __GLX_SWAP_INT((GLbyte *)&hdr->width);
  65     __GLX_SWAP_INT((GLbyte *)&hdr->height);
  66     __GLX_SWAP_FLOAT((GLbyte *)&hdr->xorig);
  67     __GLX_SWAP_FLOAT((GLbyte *)&hdr->yorig);
  68     __GLX_SWAP_FLOAT((GLbyte *)&hdr->xmove);
  69     __GLX_SWAP_FLOAT((GLbyte *)&hdr->ymove);
  70
  71     hdr->swapBytes = !hdr->swapBytes;
  72
  73 }
  74
  75 void __glXDispSwap_TexImage1D(GLbyte *pc)
  76 {
  77     __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
  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 __glXDispSwap_TexImage2D(GLbyte *pc)
 102 {
 103     __GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
 104     __GLX_DECLARE_SWAP_VARIABLES;
 105
 106     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 107     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 108     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 109     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 110
 111     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 112     __GLX_SWAP_INT((GLbyte *)&hdr->level);
 113     __GLX_SWAP_INT((GLbyte *)&hdr->components);
 114     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 115     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 116     __GLX_SWAP_INT((GLbyte *)&hdr->border);
 117     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 118     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 119
 120     /*
 121     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 122     ** the pixel data.
 123     */
 124     hdr->swapBytes = !hdr->swapBytes;
 125 }
 126
 127 void __glXDispSwap_TexImage3D(GLbyte *pc)
 128 {
 129     __GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
 130     __GLX_DECLARE_SWAP_VARIABLES;
 131
 132     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 133     __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
 134     __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
 135     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 136     __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
 137     __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
 138     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 139     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 140
 141     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 142     __GLX_SWAP_INT((GLbyte *)&hdr->level);
 143     __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
 144     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 145     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 146     __GLX_SWAP_INT((GLbyte *)&hdr->depth);
 147     __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
 148     __GLX_SWAP_INT((GLbyte *)&hdr->border);
 149     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 150     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 151
 152     /*
 153     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 154     ** the pixel data.
 155     */
 156     hdr->swapBytes = !hdr->swapBytes;
 157 }
 158
 159 void __glXDispSwap_DrawPixels(GLbyte *pc)
 160 {
 161     __GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
 162     __GLX_DECLARE_SWAP_VARIABLES;
 163
 164     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 165     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 166     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 167     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 168
 169     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 170     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 171     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 172     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 173
 174     /*
 175     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 176     ** the pixel data.
 177     */
 178     hdr->swapBytes = !hdr->swapBytes;
 179 }
 180
 181 void __glXDispSwap_TexSubImage1D(GLbyte *pc)
 182 {
 183     __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
 184     __GLX_DECLARE_SWAP_VARIABLES;
 185
 186     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 187     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 188     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 189     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 190
 191     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 192     __GLX_SWAP_INT((GLbyte *)&hdr->level);
 193     __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
 194     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 195     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 196     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 197
 198     /*
 199     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 200     ** the pixel data.
 201     */
 202     hdr->swapBytes = !hdr->swapBytes;
 203 }
 204
 205 void __glXDispSwap_TexSubImage2D(GLbyte *pc)
 206 {
 207     __GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
 208     __GLX_DECLARE_SWAP_VARIABLES;
 209
 210     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 211     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 212     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 213     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 214
 215     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 216     __GLX_SWAP_INT((GLbyte *)&hdr->level);
 217     __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
 218     __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
 219     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 220     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 221     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 222     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 223
 224     /*
 225     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 226     ** the pixel data.
 227     */
 228     hdr->swapBytes = !hdr->swapBytes;
 229 }
 230
 231 void __glXDispSwap_TexSubImage3D(GLbyte *pc)
 232 {
 233     __GLXdispatchTexSubImage3DHeader *hdr =
 234                                 (__GLXdispatchTexSubImage3DHeader *) pc;
 235
 236     __GLX_DECLARE_SWAP_VARIABLES;
 237
 238     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 239     __GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
 240     __GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
 241     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 242     __GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
 243     __GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
 244     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 245     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 246
 247     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 248     __GLX_SWAP_INT((GLbyte *)&hdr->level);
 249     __GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
 250     __GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
 251     __GLX_SWAP_INT((GLbyte *)&hdr->zoffset);
 252     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 253     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 254     __GLX_SWAP_INT((GLbyte *)&hdr->depth);
 255     __GLX_SWAP_INT((GLbyte *)&hdr->size4d);
 256     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 257     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 258
 259     /*
 260     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 261     ** the pixel data.
 262     */
 263     hdr->swapBytes = !hdr->swapBytes;
 264 }
 265
 266 void __glXDispSwap_ColorTable(GLbyte *pc)
 267 {
 268     __GLXdispatchColorTableHeader *hdr =
 269                                 (__GLXdispatchColorTableHeader *) pc;
 270     __GLX_DECLARE_SWAP_VARIABLES;
 271
 272     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 273     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 274     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 275     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 276
 277     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 278     __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
 279     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 280     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 281     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 282
 283     /*
 284     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 285     ** the pixel data.
 286     */
 287     hdr->swapBytes = !hdr->swapBytes;
 288 }
 289
 290 void __glXDispSwap_ColorSubTable(GLbyte *pc)
 291 {
 292     __GLXdispatchColorSubTableHeader *hdr =
 293                                 (__GLXdispatchColorSubTableHeader *) pc;
 294     __GLX_DECLARE_SWAP_VARIABLES;
 295
 296     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 297     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 298     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 299     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 300
 301     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 302     __GLX_SWAP_INT((GLbyte *)&hdr->start);
 303     __GLX_SWAP_INT((GLbyte *)&hdr->count);
 304     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 305     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 306
 307     /*
 308     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 309     ** the pixel data.
 310     */
 311     hdr->swapBytes = !hdr->swapBytes;
 312 }
 313
 314 void __glXDispSwap_ConvolutionFilter1D(GLbyte *pc)
 315 {
 316     __GLXdispatchConvolutionFilterHeader *hdr =
 317                                 (__GLXdispatchConvolutionFilterHeader *) pc;
 318     __GLX_DECLARE_SWAP_VARIABLES;
 319
 320     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 321     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 322     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 323     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 324
 325     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 326     __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
 327     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 328     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 329     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 330
 331     /*
 332     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 333     ** the pixel data.
 334     */
 335     hdr->swapBytes = !hdr->swapBytes;
 336 }
 337
 338 void __glXDispSwap_ConvolutionFilter2D(GLbyte *pc)
 339 {
 340     __GLXdispatchConvolutionFilterHeader *hdr =
 341                                 (__GLXdispatchConvolutionFilterHeader *) pc;
 342     __GLX_DECLARE_SWAP_VARIABLES;
 343
 344     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 345     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 346     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 347     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 348
 349     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 350     __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
 351     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 352     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 353     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 354     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 355
 356     /*
 357     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 358     ** the pixel data.
 359     */
 360     hdr->swapBytes = !hdr->swapBytes;
 361 }
 362
 363 void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
 364 {
 365     __GLXdispatchConvolutionFilterHeader *hdr =
 366                                 (__GLXdispatchConvolutionFilterHeader *) pc;
 367     GLint hdrlen, image1len;
 368     __GLX_DECLARE_SWAP_VARIABLES;
 369
 370     hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_HDR_SIZE);
 371
 372     __GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
 373     __GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
 374     __GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
 375     __GLX_SWAP_INT((GLbyte *)&hdr->alignment);
 376
 377     __GLX_SWAP_INT((GLbyte *)&hdr->target);
 378     __GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
 379     __GLX_SWAP_INT((GLbyte *)&hdr->width);
 380     __GLX_SWAP_INT((GLbyte *)&hdr->height);
 381     __GLX_SWAP_INT((GLbyte *)&hdr->format);
 382     __GLX_SWAP_INT((GLbyte *)&hdr->type);
 383
 384     /*
 385     ** Just invert swapBytes flag; the GL will figure out if it needs to swap
 386     ** the pixel data.
 387     */
 388     hdr->swapBytes = !hdr->swapBytes;
 389 }