singlepixswap.c revision 4642e01f
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#define NEED_REPLIES 32#ifdef HAVE_DIX_CONFIG_H 33#include <dix-config.h> 34#endif 35 36#include "glxserver.h" 37#include "glxext.h" 38#include "singlesize.h" 39#include "unpack.h" 40#include "indirect_dispatch.h" 41#include "indirect_size_get.h" 42#include "glapitable.h" 43#include "glapi.h" 44#include "glthread.h" 45#include "dispatch.h" 46 47int __glXDispSwap_ReadPixels(__GLXclientState *cl, GLbyte *pc) 48{ 49 GLsizei width, height; 50 GLenum format, type; 51 GLboolean swapBytes, lsbFirst; 52 GLint compsize; 53 __GLX_DECLARE_SWAP_VARIABLES; 54 __GLXcontext *cx; 55 ClientPtr client = cl->client; 56 int error; 57 char *answer, answerBuffer[200]; 58 59 __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); 60 cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); 61 if (!cx) { 62 return error; 63 } 64 65 pc += __GLX_SINGLE_HDR_SIZE; 66 __GLX_SWAP_INT(pc+0); 67 __GLX_SWAP_INT(pc+4); 68 __GLX_SWAP_INT(pc+8); 69 __GLX_SWAP_INT(pc+12); 70 __GLX_SWAP_INT(pc+16); 71 __GLX_SWAP_INT(pc+20); 72 73 width = *(GLsizei *)(pc + 8); 74 height = *(GLsizei *)(pc + 12); 75 format = *(GLenum *)(pc + 16); 76 type = *(GLenum *)(pc + 20); 77 swapBytes = *(GLboolean *)(pc + 24); 78 lsbFirst = *(GLboolean *)(pc + 25); 79 compsize = __glReadPixels_size(format,type,width,height); 80 if (compsize < 0) compsize = 0; 81 82 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 83 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) ); 84 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 85 __glXClearErrorOccured(); 86 CALL_ReadPixels( GET_DISPATCH(), 87 (*(GLint *)(pc + 0), 88 *(GLint *)(pc + 4), 89 *(GLsizei *)(pc + 8), 90 *(GLsizei *)(pc + 12), 91 *(GLenum *)(pc + 16), 92 *(GLenum *)(pc + 20), 93 answer) 94 ); 95 96 if (__glXErrorOccured()) { 97 __GLX_BEGIN_REPLY(0); 98 __GLX_SWAP_REPLY_HEADER(); 99 __GLX_SEND_HEADER(); 100 } else { 101 __GLX_BEGIN_REPLY(compsize); 102 __GLX_SWAP_REPLY_HEADER(); 103 __GLX_SEND_HEADER(); 104 __GLX_SEND_VOID_ARRAY(compsize); 105 } 106 return Success; 107} 108 109int __glXDispSwap_GetTexImage(__GLXclientState *cl, GLbyte *pc) 110{ 111 GLint level, compsize; 112 GLenum format, type, target; 113 GLboolean swapBytes; 114 __GLX_DECLARE_SWAP_VARIABLES; 115 __GLXcontext *cx; 116 ClientPtr client = cl->client; 117 int error; 118 char *answer, answerBuffer[200]; 119 GLint width=0, height=0, depth=1; 120 121 __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); 122 cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); 123 if (!cx) { 124 return error; 125 } 126 127 pc += __GLX_SINGLE_HDR_SIZE; 128 __GLX_SWAP_INT(pc+0); 129 __GLX_SWAP_INT(pc+4); 130 __GLX_SWAP_INT(pc+8); 131 __GLX_SWAP_INT(pc+12); 132 133 level = *(GLint *)(pc + 4); 134 format = *(GLenum *)(pc + 8); 135 type = *(GLenum *)(pc + 12); 136 target = *(GLenum *)(pc + 0); 137 swapBytes = *(GLboolean *)(pc + 16); 138 139 CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_WIDTH, &width) ); 140 CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_HEIGHT, &height) ); 141 if ( target == GL_TEXTURE_3D) { 142 CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_DEPTH, &depth) ); 143 } 144 /* 145 * The three queries above might fail if we're in a state where queries 146 * are illegal, but then width, height, and depth would still be zero anyway. 147 */ 148 compsize = __glGetTexImage_size(target,level,format,type,width,height,depth); 149 if (compsize < 0) compsize = 0; 150 151 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 152 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 153 __glXClearErrorOccured(); 154 CALL_GetTexImage( GET_DISPATCH(), ( 155 *(GLenum *)(pc + 0), 156 *(GLint *)(pc + 4), 157 *(GLenum *)(pc + 8), 158 *(GLenum *)(pc + 12), 159 answer 160 ) ); 161 162 if (__glXErrorOccured()) { 163 __GLX_BEGIN_REPLY(0); 164 __GLX_SWAP_REPLY_HEADER(); 165 __GLX_SEND_HEADER(); 166 } else { 167 __GLX_BEGIN_REPLY(compsize); 168 __GLX_SWAP_REPLY_HEADER(); 169 __GLX_SWAP_INT(&width); 170 __GLX_SWAP_INT(&height); 171 __GLX_SWAP_INT(&depth); 172 ((xGLXGetTexImageReply *)&__glXReply)->width = width; 173 ((xGLXGetTexImageReply *)&__glXReply)->height = height; 174 ((xGLXGetTexImageReply *)&__glXReply)->depth = depth; 175 __GLX_SEND_HEADER(); 176 __GLX_SEND_VOID_ARRAY(compsize); 177 } 178 return Success; 179} 180 181int __glXDispSwap_GetPolygonStipple(__GLXclientState *cl, GLbyte *pc) 182{ 183 GLboolean lsbFirst; 184 __GLXcontext *cx; 185 ClientPtr client = cl->client; 186 int error; 187 GLubyte answerBuffer[200]; 188 char *answer; 189 __GLX_DECLARE_SWAP_VARIABLES; 190 191 __GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag); 192 cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error); 193 if (!cx) { 194 return error; 195 } 196 pc += __GLX_SINGLE_HDR_SIZE; 197 lsbFirst = *(GLboolean *)(pc + 0); 198 199 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) ); 200 __GLX_GET_ANSWER_BUFFER(answer,cl,128,1); 201 202 __glXClearErrorOccured(); 203 CALL_GetPolygonStipple( GET_DISPATCH(), ((GLubyte *) answer) ); 204 if (__glXErrorOccured()) { 205 __GLX_BEGIN_REPLY(0); 206 __GLX_SWAP_REPLY_HEADER(); 207 __GLX_SEND_HEADER(); 208 } else { 209 __GLX_BEGIN_REPLY(128); 210 __GLX_SWAP_REPLY_HEADER(); 211 __GLX_SEND_HEADER(); 212 __GLX_SEND_BYTE_ARRAY(128); 213 } 214 return Success; 215} 216 217static int GetSeparableFilter(__GLXclientState *cl, GLbyte *pc, GLXContextTag tag) 218{ 219 GLint compsize, compsize2; 220 GLenum format, type, target; 221 GLboolean swapBytes; 222 __GLXcontext *cx; 223 ClientPtr client = cl->client; 224 int error; 225 __GLX_DECLARE_SWAP_VARIABLES; 226 char *answer, answerBuffer[200]; 227 GLint width=0, height=0; 228 229 cx = __glXForceCurrent(cl, tag, &error); 230 if (!cx) { 231 return error; 232 } 233 234 __GLX_SWAP_INT(pc+0); 235 __GLX_SWAP_INT(pc+4); 236 __GLX_SWAP_INT(pc+8); 237 238 format = *(GLenum *)(pc + 4); 239 type = *(GLenum *)(pc + 8); 240 target = *(GLenum *)(pc + 0); 241 swapBytes = *(GLboolean *)(pc + 12); 242 243 /* target must be SEPARABLE_2D, however I guess we can let the GL 244 barf on this one.... */ 245 246 CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) ); 247 CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) ); 248 /* 249 * The two queries above might fail if we're in a state where queries 250 * are illegal, but then width and height would still be zero anyway. 251 */ 252 compsize = __glGetTexImage_size(target,1,format,type,width,1,1); 253 compsize2 = __glGetTexImage_size(target,1,format,type,height,1,1); 254 255 if (compsize < 0) compsize = 0; 256 if (compsize2 < 0) compsize2 = 0; 257 compsize = __GLX_PAD(compsize); 258 compsize2 = __GLX_PAD(compsize2); 259 260 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 261 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1); 262 __glXClearErrorOccured(); 263 CALL_GetSeparableFilter( GET_DISPATCH(), ( 264 *(GLenum *)(pc + 0), 265 *(GLenum *)(pc + 4), 266 *(GLenum *)(pc + 8), 267 answer, 268 answer + compsize, 269 NULL 270 ) ); 271 272 if (__glXErrorOccured()) { 273 __GLX_BEGIN_REPLY(0); 274 __GLX_SWAP_REPLY_HEADER(); 275 } else { 276 __GLX_BEGIN_REPLY(compsize + compsize2); 277 __GLX_SWAP_REPLY_HEADER(); 278 __GLX_SWAP_INT(&width); 279 __GLX_SWAP_INT(&height); 280 ((xGLXGetSeparableFilterReply *)&__glXReply)->width = width; 281 ((xGLXGetSeparableFilterReply *)&__glXReply)->height = height; 282 __GLX_SEND_VOID_ARRAY(compsize + compsize2); 283 } 284 285 return Success; 286} 287 288int __glXDispSwap_GetSeparableFilter(__GLXclientState *cl, GLbyte *pc) 289{ 290 const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); 291 292 return GetSeparableFilter(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); 293} 294 295int __glXDispSwap_GetSeparableFilterEXT(__GLXclientState *cl, GLbyte *pc) 296{ 297 const GLXContextTag tag = __GLX_GET_VENDPRIV_CONTEXT_TAG(pc); 298 299 return GetSeparableFilter(cl, pc + __GLX_VENDPRIV_HDR_SIZE, tag); 300} 301 302static int GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc, GLXContextTag tag) 303{ 304 GLint compsize; 305 GLenum format, type, target; 306 GLboolean swapBytes; 307 __GLXcontext *cx; 308 ClientPtr client = cl->client; 309 int error; 310 __GLX_DECLARE_SWAP_VARIABLES; 311 char *answer, answerBuffer[200]; 312 GLint width=0, height=0; 313 314 cx = __glXForceCurrent(cl, tag, &error); 315 if (!cx) { 316 return error; 317 } 318 319 __GLX_SWAP_INT(pc+0); 320 __GLX_SWAP_INT(pc+4); 321 __GLX_SWAP_INT(pc+8); 322 323 format = *(GLenum *)(pc + 4); 324 type = *(GLenum *)(pc + 8); 325 target = *(GLenum *)(pc + 0); 326 swapBytes = *(GLboolean *)(pc + 12); 327 328 CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) ); 329 if (target == GL_CONVOLUTION_2D) { 330 height = 1; 331 } else { 332 CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) ); 333 } 334 /* 335 * The two queries above might fail if we're in a state where queries 336 * are illegal, but then width and height would still be zero anyway. 337 */ 338 compsize = __glGetTexImage_size(target,1,format,type,width,height,1); 339 if (compsize < 0) compsize = 0; 340 341 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 342 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 343 __glXClearErrorOccured(); 344 CALL_GetConvolutionFilter( GET_DISPATCH(), ( 345 *(GLenum *)(pc + 0), 346 *(GLenum *)(pc + 4), 347 *(GLenum *)(pc + 8), 348 answer 349 ) ); 350 351 if (__glXErrorOccured()) { 352 __GLX_BEGIN_REPLY(0); 353 __GLX_SWAP_REPLY_HEADER(); 354 } else { 355 __GLX_BEGIN_REPLY(compsize); 356 __GLX_SWAP_REPLY_HEADER(); 357 __GLX_SWAP_INT(&width); 358 __GLX_SWAP_INT(&height); 359 ((xGLXGetConvolutionFilterReply *)&__glXReply)->width = width; 360 ((xGLXGetConvolutionFilterReply *)&__glXReply)->height = height; 361 __GLX_SEND_VOID_ARRAY(compsize); 362 } 363 364 return Success; 365} 366 367int __glXDispSwap_GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc) 368{ 369 const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); 370 371 return GetConvolutionFilter(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); 372} 373 374int __glXDispSwap_GetConvolutionFilterEXT(__GLXclientState *cl, GLbyte *pc) 375{ 376 const GLXContextTag tag = __GLX_GET_VENDPRIV_CONTEXT_TAG(pc); 377 378 return GetConvolutionFilter(cl, pc + __GLX_VENDPRIV_HDR_SIZE, tag); 379} 380 381static int GetHistogram(__GLXclientState *cl, GLbyte *pc, GLXContextTag tag) 382{ 383 GLint compsize; 384 GLenum format, type, target; 385 GLboolean swapBytes, reset; 386 __GLXcontext *cx; 387 ClientPtr client = cl->client; 388 int error; 389 __GLX_DECLARE_SWAP_VARIABLES; 390 char *answer, answerBuffer[200]; 391 GLint width=0; 392 393 cx = __glXForceCurrent(cl, tag, &error); 394 if (!cx) { 395 return error; 396 } 397 398 __GLX_SWAP_INT(pc+0); 399 __GLX_SWAP_INT(pc+4); 400 __GLX_SWAP_INT(pc+8); 401 402 format = *(GLenum *)(pc + 4); 403 type = *(GLenum *)(pc + 8); 404 target = *(GLenum *)(pc + 0); 405 swapBytes = *(GLboolean *)(pc + 12); 406 reset = *(GLboolean *)(pc + 13); 407 408 CALL_GetHistogramParameteriv( GET_DISPATCH(), (target, GL_HISTOGRAM_WIDTH, &width) ); 409 /* 410 * The one query above might fail if we're in a state where queries 411 * are illegal, but then width would still be zero anyway. 412 */ 413 compsize = __glGetTexImage_size(target,1,format,type,width,1,1); 414 if (compsize < 0) compsize = 0; 415 416 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 417 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 418 __glXClearErrorOccured(); 419 CALL_GetHistogram( GET_DISPATCH(), (target, reset, format, type, answer) ); 420 421 if (__glXErrorOccured()) { 422 __GLX_BEGIN_REPLY(0); 423 __GLX_SWAP_REPLY_HEADER(); 424 } else { 425 __GLX_BEGIN_REPLY(compsize); 426 __GLX_SWAP_REPLY_HEADER(); 427 __GLX_SWAP_INT(&width); 428 ((xGLXGetHistogramReply *)&__glXReply)->width = width; 429 __GLX_SEND_VOID_ARRAY(compsize); 430 } 431 432 return Success; 433} 434 435int __glXDispSwap_GetHistogram(__GLXclientState *cl, GLbyte *pc) 436{ 437 const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); 438 439 return GetHistogram(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); 440} 441 442int __glXDispSwap_GetHistogramEXT(__GLXclientState *cl, GLbyte *pc) 443{ 444 const GLXContextTag tag = __GLX_GET_VENDPRIV_CONTEXT_TAG(pc); 445 446 return GetHistogram(cl, pc + __GLX_VENDPRIV_HDR_SIZE, tag); 447} 448 449static int GetMinmax(__GLXclientState *cl, GLbyte *pc, GLXContextTag tag) 450{ 451 GLint compsize; 452 GLenum format, type, target; 453 GLboolean swapBytes, reset; 454 __GLXcontext *cx; 455 ClientPtr client = cl->client; 456 int error; 457 __GLX_DECLARE_SWAP_VARIABLES; 458 char *answer, answerBuffer[200]; 459 460 cx = __glXForceCurrent(cl, tag, &error); 461 if (!cx) { 462 return error; 463 } 464 465 __GLX_SWAP_INT(pc+0); 466 __GLX_SWAP_INT(pc+4); 467 __GLX_SWAP_INT(pc+8); 468 469 format = *(GLenum *)(pc + 4); 470 type = *(GLenum *)(pc + 8); 471 target = *(GLenum *)(pc + 0); 472 swapBytes = *(GLboolean *)(pc + 12); 473 reset = *(GLboolean *)(pc + 13); 474 475 compsize = __glGetTexImage_size(target,1,format,type,2,1,1); 476 if (compsize < 0) compsize = 0; 477 478 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 479 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 480 __glXClearErrorOccured(); 481 CALL_GetMinmax( GET_DISPATCH(), (target, reset, format, type, answer) ); 482 483 if (__glXErrorOccured()) { 484 __GLX_BEGIN_REPLY(0); 485 __GLX_SWAP_REPLY_HEADER(); 486 } else { 487 __GLX_BEGIN_REPLY(compsize); 488 __GLX_SWAP_REPLY_HEADER(); 489 __GLX_SEND_VOID_ARRAY(compsize); 490 } 491 492 return Success; 493} 494 495int __glXDispSwap_GetMinmax(__GLXclientState *cl, GLbyte *pc) 496{ 497 const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); 498 499 return GetMinmax(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); 500} 501 502int __glXDispSwap_GetMinmaxEXT(__GLXclientState *cl, GLbyte *pc) 503{ 504 const GLXContextTag tag = __GLX_GET_VENDPRIV_CONTEXT_TAG(pc); 505 506 return GetMinmax(cl, pc + __GLX_VENDPRIV_HDR_SIZE, tag); 507} 508 509static int GetColorTable(__GLXclientState *cl, GLbyte *pc, GLXContextTag tag) 510{ 511 GLint compsize; 512 GLenum format, type, target; 513 GLboolean swapBytes; 514 __GLXcontext *cx; 515 ClientPtr client = cl->client; 516 int error; 517 __GLX_DECLARE_SWAP_VARIABLES; 518 char *answer, answerBuffer[200]; 519 GLint width=0; 520 521 cx = __glXForceCurrent(cl, tag, &error); 522 if (!cx) { 523 return error; 524 } 525 526 __GLX_SWAP_INT(pc+0); 527 __GLX_SWAP_INT(pc+4); 528 __GLX_SWAP_INT(pc+8); 529 530 format = *(GLenum *)(pc + 4); 531 type = *(GLenum *)(pc + 8); 532 target = *(GLenum *)(pc + 0); 533 swapBytes = *(GLboolean *)(pc + 12); 534 535 CALL_GetColorTableParameteriv( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) ); 536 /* 537 * The one query above might fail if we're in a state where queries 538 * are illegal, but then width would still be zero anyway. 539 */ 540 compsize = __glGetTexImage_size(target,1,format,type,width,1,1); 541 if (compsize < 0) compsize = 0; 542 543 CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) ); 544 __GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1); 545 __glXClearErrorOccured(); 546 CALL_GetColorTable( GET_DISPATCH(), ( 547 *(GLenum *)(pc + 0), 548 *(GLenum *)(pc + 4), 549 *(GLenum *)(pc + 8), 550 answer 551 ) ); 552 553 if (__glXErrorOccured()) { 554 __GLX_BEGIN_REPLY(0); 555 __GLX_SWAP_REPLY_HEADER(); 556 } else { 557 __GLX_BEGIN_REPLY(compsize); 558 __GLX_SWAP_REPLY_HEADER(); 559 __GLX_SWAP_INT(&width); 560 ((xGLXGetColorTableReply *)&__glXReply)->width = width; 561 __GLX_SEND_VOID_ARRAY(compsize); 562 } 563 564 return Success; 565} 566 567int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc) 568{ 569 const GLXContextTag tag = __GLX_GET_SINGLE_CONTEXT_TAG(pc); 570 571 return GetColorTable(cl, pc + __GLX_SINGLE_HDR_SIZE, tag); 572} 573 574int __glXDispSwap_GetColorTableSGI(__GLXclientState *cl, GLbyte *pc) 575{ 576 const GLXContextTag tag = __GLX_GET_VENDPRIV_CONTEXT_TAG(pc); 577 578 return GetColorTable(cl, pc + __GLX_VENDPRIV_HDR_SIZE, tag); 579} 580