histogram.c revision 7117f1b4
1/* 2 * Mesa 3-D graphics library 3 * Version: 6.3 4 * 5 * Copyright (C) 1999-2004 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * 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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 26#include "glheader.h" 27#include "bufferobj.h" 28#include "colormac.h" 29#include "context.h" 30#include "image.h" 31#include "histogram.h" 32 33 34/********************************************************************** 35 * Internal functions 36 */ 37 38 39/* 40 * Update the min/max values from an array of fragment colors. 41 */ 42void 43_mesa_update_minmax(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 44{ 45 GLuint i; 46 for (i = 0; i < n; i++) { 47 /* update mins */ 48 if (rgba[i][RCOMP] < ctx->MinMax.Min[RCOMP]) 49 ctx->MinMax.Min[RCOMP] = rgba[i][RCOMP]; 50 if (rgba[i][GCOMP] < ctx->MinMax.Min[GCOMP]) 51 ctx->MinMax.Min[GCOMP] = rgba[i][GCOMP]; 52 if (rgba[i][BCOMP] < ctx->MinMax.Min[BCOMP]) 53 ctx->MinMax.Min[BCOMP] = rgba[i][BCOMP]; 54 if (rgba[i][ACOMP] < ctx->MinMax.Min[ACOMP]) 55 ctx->MinMax.Min[ACOMP] = rgba[i][ACOMP]; 56 57 /* update maxs */ 58 if (rgba[i][RCOMP] > ctx->MinMax.Max[RCOMP]) 59 ctx->MinMax.Max[RCOMP] = rgba[i][RCOMP]; 60 if (rgba[i][GCOMP] > ctx->MinMax.Max[GCOMP]) 61 ctx->MinMax.Max[GCOMP] = rgba[i][GCOMP]; 62 if (rgba[i][BCOMP] > ctx->MinMax.Max[BCOMP]) 63 ctx->MinMax.Max[BCOMP] = rgba[i][BCOMP]; 64 if (rgba[i][ACOMP] > ctx->MinMax.Max[ACOMP]) 65 ctx->MinMax.Max[ACOMP] = rgba[i][ACOMP]; 66 } 67} 68 69 70/* 71 * Update the histogram values from an array of fragment colors. 72 */ 73void 74_mesa_update_histogram(GLcontext *ctx, GLuint n, const GLfloat rgba[][4]) 75{ 76 const GLint max = ctx->Histogram.Width - 1; 77 GLfloat w = (GLfloat) max; 78 GLuint i; 79 80 if (ctx->Histogram.Width == 0) 81 return; 82 83 for (i = 0; i < n; i++) { 84 GLint ri = IROUND(rgba[i][RCOMP] * w); 85 GLint gi = IROUND(rgba[i][GCOMP] * w); 86 GLint bi = IROUND(rgba[i][BCOMP] * w); 87 GLint ai = IROUND(rgba[i][ACOMP] * w); 88 ri = CLAMP(ri, 0, max); 89 gi = CLAMP(gi, 0, max); 90 bi = CLAMP(bi, 0, max); 91 ai = CLAMP(ai, 0, max); 92 ctx->Histogram.Count[ri][RCOMP]++; 93 ctx->Histogram.Count[gi][GCOMP]++; 94 ctx->Histogram.Count[bi][BCOMP]++; 95 ctx->Histogram.Count[ai][ACOMP]++; 96 } 97} 98 99 100/* 101 * XXX the packed pixel formats haven't been tested. 102 */ 103static void 104pack_histogram( GLcontext *ctx, 105 GLuint n, CONST GLuint rgba[][4], 106 GLenum format, GLenum type, GLvoid *destination, 107 const struct gl_pixelstore_attrib *packing ) 108{ 109 const GLint comps = _mesa_components_in_format(format); 110 GLuint luminance[MAX_WIDTH]; 111 112 if (format == GL_LUMINANCE || format == GL_LUMINANCE_ALPHA) { 113 GLuint i; 114 for (i = 0; i < n; i++) { 115 luminance[i] = rgba[i][RCOMP] + rgba[i][GCOMP] + rgba[i][BCOMP]; 116 } 117 } 118 119#define PACK_MACRO(TYPE) \ 120 { \ 121 GLuint i; \ 122 switch (format) { \ 123 case GL_RED: \ 124 for (i=0;i<n;i++) \ 125 dst[i] = (TYPE) rgba[i][RCOMP]; \ 126 break; \ 127 case GL_GREEN: \ 128 for (i=0;i<n;i++) \ 129 dst[i] = (TYPE) rgba[i][GCOMP]; \ 130 break; \ 131 case GL_BLUE: \ 132 for (i=0;i<n;i++) \ 133 dst[i] = (TYPE) rgba[i][BCOMP]; \ 134 break; \ 135 case GL_ALPHA: \ 136 for (i=0;i<n;i++) \ 137 dst[i] = (TYPE) rgba[i][ACOMP]; \ 138 break; \ 139 case GL_LUMINANCE: \ 140 for (i=0;i<n;i++) \ 141 dst[i] = (TYPE) luminance[i]; \ 142 break; \ 143 case GL_LUMINANCE_ALPHA: \ 144 for (i=0;i<n;i++) { \ 145 dst[i*2+0] = (TYPE) luminance[i]; \ 146 dst[i*2+1] = (TYPE) rgba[i][ACOMP]; \ 147 } \ 148 break; \ 149 case GL_RGB: \ 150 for (i=0;i<n;i++) { \ 151 dst[i*3+0] = (TYPE) rgba[i][RCOMP]; \ 152 dst[i*3+1] = (TYPE) rgba[i][GCOMP]; \ 153 dst[i*3+2] = (TYPE) rgba[i][BCOMP]; \ 154 } \ 155 break; \ 156 case GL_RGBA: \ 157 for (i=0;i<n;i++) { \ 158 dst[i*4+0] = (TYPE) rgba[i][RCOMP]; \ 159 dst[i*4+1] = (TYPE) rgba[i][GCOMP]; \ 160 dst[i*4+2] = (TYPE) rgba[i][BCOMP]; \ 161 dst[i*4+3] = (TYPE) rgba[i][ACOMP]; \ 162 } \ 163 break; \ 164 case GL_BGR: \ 165 for (i=0;i<n;i++) { \ 166 dst[i*3+0] = (TYPE) rgba[i][BCOMP]; \ 167 dst[i*3+1] = (TYPE) rgba[i][GCOMP]; \ 168 dst[i*3+2] = (TYPE) rgba[i][RCOMP]; \ 169 } \ 170 break; \ 171 case GL_BGRA: \ 172 for (i=0;i<n;i++) { \ 173 dst[i*4+0] = (TYPE) rgba[i][BCOMP]; \ 174 dst[i*4+1] = (TYPE) rgba[i][GCOMP]; \ 175 dst[i*4+2] = (TYPE) rgba[i][RCOMP]; \ 176 dst[i*4+3] = (TYPE) rgba[i][ACOMP]; \ 177 } \ 178 break; \ 179 case GL_ABGR_EXT: \ 180 for (i=0;i<n;i++) { \ 181 dst[i*4+0] = (TYPE) rgba[i][ACOMP]; \ 182 dst[i*4+1] = (TYPE) rgba[i][BCOMP]; \ 183 dst[i*4+2] = (TYPE) rgba[i][GCOMP]; \ 184 dst[i*4+3] = (TYPE) rgba[i][RCOMP]; \ 185 } \ 186 break; \ 187 default: \ 188 _mesa_problem(ctx, "bad format in pack_histogram"); \ 189 } \ 190 } 191 192 switch (type) { 193 case GL_UNSIGNED_BYTE: 194 { 195 GLubyte *dst = (GLubyte *) destination; 196 PACK_MACRO(GLubyte); 197 } 198 break; 199 case GL_BYTE: 200 { 201 GLbyte *dst = (GLbyte *) destination; 202 PACK_MACRO(GLbyte); 203 } 204 break; 205 case GL_UNSIGNED_SHORT: 206 { 207 GLushort *dst = (GLushort *) destination; 208 PACK_MACRO(GLushort); 209 if (packing->SwapBytes) { 210 _mesa_swap2(dst, n * comps); 211 } 212 } 213 break; 214 case GL_SHORT: 215 { 216 GLshort *dst = (GLshort *) destination; 217 PACK_MACRO(GLshort); 218 if (packing->SwapBytes) { 219 _mesa_swap2((GLushort *) dst, n * comps); 220 } 221 } 222 break; 223 case GL_UNSIGNED_INT: 224 { 225 GLuint *dst = (GLuint *) destination; 226 PACK_MACRO(GLuint); 227 if (packing->SwapBytes) { 228 _mesa_swap4(dst, n * comps); 229 } 230 } 231 break; 232 case GL_INT: 233 { 234 GLint *dst = (GLint *) destination; 235 PACK_MACRO(GLint); 236 if (packing->SwapBytes) { 237 _mesa_swap4((GLuint *) dst, n * comps); 238 } 239 } 240 break; 241 case GL_FLOAT: 242 { 243 GLfloat *dst = (GLfloat *) destination; 244 PACK_MACRO(GLfloat); 245 if (packing->SwapBytes) { 246 _mesa_swap4((GLuint *) dst, n * comps); 247 } 248 } 249 break; 250 case GL_HALF_FLOAT_ARB: 251 { 252 /* temporarily store as GLuints */ 253 GLuint temp[4*HISTOGRAM_TABLE_SIZE]; 254 GLhalfARB *dst = (GLhalfARB *) destination; 255 GLuint i; 256 /* get GLuint values */ 257 PACK_MACRO(GLuint); 258 /* convert to GLhalf */ 259 for (i = 0; i < n * comps; i++) { 260 dst[i] = _mesa_float_to_half((GLfloat) temp[i]); 261 } 262 if (packing->SwapBytes) { 263 _mesa_swap2((GLushort *) dst, n * comps); 264 } 265 } 266 break; 267 case GL_UNSIGNED_BYTE_3_3_2: 268 if (format == GL_RGB) { 269 GLubyte *dst = (GLubyte *) destination; 270 GLuint i; 271 for (i = 0; i < n; i++) { 272 dst[i] = ((rgba[i][RCOMP] & 0x7) << 5) 273 | ((rgba[i][GCOMP] & 0x7) << 2) 274 | ((rgba[i][BCOMP] & 0x3) ); 275 } 276 } 277 else { 278 GLubyte *dst = (GLubyte *) destination; 279 GLuint i; 280 ASSERT(format == GL_BGR); 281 for (i = 0; i < n; i++) { 282 dst[i] = ((rgba[i][BCOMP] & 0x7) << 5) 283 | ((rgba[i][GCOMP] & 0x7) << 2) 284 | ((rgba[i][RCOMP] & 0x3) ); 285 } 286 } 287 break; 288 case GL_UNSIGNED_BYTE_2_3_3_REV: 289 if (format == GL_RGB) { 290 GLubyte *dst = (GLubyte *) destination; 291 GLuint i; 292 for (i = 0; i < n; i++) { 293 dst[i] = ((rgba[i][RCOMP] & 0x3) << 6) 294 | ((rgba[i][GCOMP] & 0x7) << 3) 295 | ((rgba[i][BCOMP] & 0x7) ); 296 } 297 } 298 else { 299 GLubyte *dst = (GLubyte *) destination; 300 GLuint i; 301 ASSERT(format == GL_BGR); 302 for (i = 0; i < n; i++) { 303 dst[i] = ((rgba[i][BCOMP] & 0x3) << 6) 304 | ((rgba[i][GCOMP] & 0x7) << 3) 305 | ((rgba[i][RCOMP] & 0x7) ); 306 } 307 } 308 break; 309 case GL_UNSIGNED_SHORT_5_6_5: 310 if (format == GL_RGB) { 311 GLushort *dst = (GLushort *) destination; 312 GLuint i; 313 for (i = 0; i < n; i++) { 314 dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11) 315 | ((rgba[i][GCOMP] & 0x3f) << 5) 316 | ((rgba[i][BCOMP] & 0x1f) ); 317 } 318 } 319 else { 320 GLushort *dst = (GLushort *) destination; 321 GLuint i; 322 ASSERT(format == GL_BGR); 323 for (i = 0; i < n; i++) { 324 dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11) 325 | ((rgba[i][GCOMP] & 0x3f) << 5) 326 | ((rgba[i][RCOMP] & 0x1f) ); 327 } 328 } 329 break; 330 case GL_UNSIGNED_SHORT_5_6_5_REV: 331 if (format == GL_RGB) { 332 GLushort *dst = (GLushort *) destination; 333 GLuint i; 334 for (i = 0; i < n; i++) { 335 dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11) 336 | ((rgba[i][GCOMP] & 0x3f) << 5) 337 | ((rgba[i][RCOMP] & 0x1f) ); 338 } 339 } 340 else { 341 GLushort *dst = (GLushort *) destination; 342 GLuint i; 343 ASSERT(format == GL_BGR); 344 for (i = 0; i < n; i++) { 345 dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11) 346 | ((rgba[i][GCOMP] & 0x3f) << 5) 347 | ((rgba[i][BCOMP] & 0x1f) ); 348 } 349 } 350 break; 351 case GL_UNSIGNED_SHORT_4_4_4_4: 352 if (format == GL_RGBA) { 353 GLushort *dst = (GLushort *) destination; 354 GLuint i; 355 for (i = 0; i < n; i++) { 356 dst[i] = ((rgba[i][RCOMP] & 0xf) << 12) 357 | ((rgba[i][GCOMP] & 0xf) << 8) 358 | ((rgba[i][BCOMP] & 0xf) << 4) 359 | ((rgba[i][ACOMP] & 0xf) ); 360 } 361 } 362 else if (format == GL_BGRA) { 363 GLushort *dst = (GLushort *) destination; 364 GLuint i; 365 for (i = 0; i < n; i++) { 366 dst[i] = ((rgba[i][BCOMP] & 0xf) << 12) 367 | ((rgba[i][GCOMP] & 0xf) << 8) 368 | ((rgba[i][RCOMP] & 0xf) << 4) 369 | ((rgba[i][ACOMP] & 0xf) ); 370 } 371 } 372 else { 373 GLushort *dst = (GLushort *) destination; 374 GLuint i; 375 ASSERT(format == GL_ABGR_EXT); 376 for (i = 0; i < n; i++) { 377 dst[i] = ((rgba[i][ACOMP] & 0xf) << 12) 378 | ((rgba[i][BCOMP] & 0xf) << 8) 379 | ((rgba[i][GCOMP] & 0xf) << 4) 380 | ((rgba[i][RCOMP] & 0xf) ); 381 } 382 } 383 break; 384 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 385 if (format == GL_RGBA) { 386 GLushort *dst = (GLushort *) destination; 387 GLuint i; 388 for (i = 0; i < n; i++) { 389 dst[i] = ((rgba[i][ACOMP] & 0xf) << 12) 390 | ((rgba[i][BCOMP] & 0xf) << 8) 391 | ((rgba[i][GCOMP] & 0xf) << 4) 392 | ((rgba[i][RCOMP] & 0xf) ); 393 } 394 } 395 else if (format == GL_BGRA) { 396 GLushort *dst = (GLushort *) destination; 397 GLuint i; 398 for (i = 0; i < n; i++) { 399 dst[i] = ((rgba[i][ACOMP] & 0xf) << 12) 400 | ((rgba[i][RCOMP] & 0xf) << 8) 401 | ((rgba[i][GCOMP] & 0xf) << 4) 402 | ((rgba[i][BCOMP] & 0xf) ); 403 } 404 } 405 else { 406 GLushort *dst = (GLushort *) destination; 407 GLuint i; 408 ASSERT(format == GL_ABGR_EXT); 409 for (i = 0; i < n; i++) { 410 dst[i] = ((rgba[i][RCOMP] & 0xf) << 12) 411 | ((rgba[i][GCOMP] & 0xf) << 8) 412 | ((rgba[i][BCOMP] & 0xf) << 4) 413 | ((rgba[i][ACOMP] & 0xf) ); 414 } 415 } 416 break; 417 case GL_UNSIGNED_SHORT_5_5_5_1: 418 if (format == GL_RGBA) { 419 GLushort *dst = (GLushort *) destination; 420 GLuint i; 421 for (i = 0; i < n; i++) { 422 dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11) 423 | ((rgba[i][GCOMP] & 0x1f) << 6) 424 | ((rgba[i][BCOMP] & 0x1f) << 1) 425 | ((rgba[i][ACOMP] & 0x1) ); 426 } 427 } 428 else if (format == GL_BGRA) { 429 GLushort *dst = (GLushort *) destination; 430 GLuint i; 431 for (i = 0; i < n; i++) { 432 dst[i] = ((rgba[i][BCOMP] & 0x1f) << 11) 433 | ((rgba[i][GCOMP] & 0x1f) << 6) 434 | ((rgba[i][RCOMP] & 0x1f) << 1) 435 | ((rgba[i][ACOMP] & 0x1) ); 436 } 437 } 438 else { 439 GLushort *dst = (GLushort *) destination; 440 GLuint i; 441 ASSERT(format == GL_ABGR_EXT); 442 for (i = 0; i < n; i++) { 443 dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11) 444 | ((rgba[i][BCOMP] & 0x1f) << 6) 445 | ((rgba[i][GCOMP] & 0x1f) << 1) 446 | ((rgba[i][RCOMP] & 0x1) ); 447 } 448 } 449 break; 450 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 451 if (format == GL_RGBA) { 452 GLushort *dst = (GLushort *) destination; 453 GLuint i; 454 for (i = 0; i < n; i++) { 455 dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11) 456 | ((rgba[i][BCOMP] & 0x1f) << 6) 457 | ((rgba[i][GCOMP] & 0x1f) << 1) 458 | ((rgba[i][RCOMP] & 0x1) ); 459 } 460 } 461 else if (format == GL_BGRA) { 462 GLushort *dst = (GLushort *) destination; 463 GLuint i; 464 for (i = 0; i < n; i++) { 465 dst[i] = ((rgba[i][ACOMP] & 0x1f) << 11) 466 | ((rgba[i][RCOMP] & 0x1f) << 6) 467 | ((rgba[i][GCOMP] & 0x1f) << 1) 468 | ((rgba[i][BCOMP] & 0x1) ); 469 } 470 } 471 else { 472 GLushort *dst = (GLushort *) destination; 473 GLuint i; 474 ASSERT(format == GL_ABGR_EXT); 475 for (i = 0; i < n; i++) { 476 dst[i] = ((rgba[i][RCOMP] & 0x1f) << 11) 477 | ((rgba[i][GCOMP] & 0x1f) << 6) 478 | ((rgba[i][BCOMP] & 0x1f) << 1) 479 | ((rgba[i][ACOMP] & 0x1) ); 480 } 481 } 482 break; 483 case GL_UNSIGNED_INT_8_8_8_8: 484 if (format == GL_RGBA) { 485 GLuint *dst = (GLuint *) destination; 486 GLuint i; 487 for (i = 0; i < n; i++) { 488 dst[i] = ((rgba[i][RCOMP] & 0xff) << 24) 489 | ((rgba[i][GCOMP] & 0xff) << 16) 490 | ((rgba[i][BCOMP] & 0xff) << 8) 491 | ((rgba[i][ACOMP] & 0xff) ); 492 } 493 } 494 else if (format == GL_BGRA) { 495 GLuint *dst = (GLuint *) destination; 496 GLuint i; 497 for (i = 0; i < n; i++) { 498 dst[i] = ((rgba[i][BCOMP] & 0xff) << 24) 499 | ((rgba[i][GCOMP] & 0xff) << 16) 500 | ((rgba[i][RCOMP] & 0xff) << 8) 501 | ((rgba[i][ACOMP] & 0xff) ); 502 } 503 } 504 else { 505 GLuint *dst = (GLuint *) destination; 506 GLuint i; 507 ASSERT(format == GL_ABGR_EXT); 508 for (i = 0; i < n; i++) { 509 dst[i] = ((rgba[i][ACOMP] & 0xff) << 24) 510 | ((rgba[i][BCOMP] & 0xff) << 16) 511 | ((rgba[i][GCOMP] & 0xff) << 8) 512 | ((rgba[i][RCOMP] & 0xff) ); 513 } 514 } 515 break; 516 case GL_UNSIGNED_INT_8_8_8_8_REV: 517 if (format == GL_RGBA) { 518 GLuint *dst = (GLuint *) destination; 519 GLuint i; 520 for (i = 0; i < n; i++) { 521 dst[i] = ((rgba[i][ACOMP] & 0xff) << 24) 522 | ((rgba[i][BCOMP] & 0xff) << 16) 523 | ((rgba[i][GCOMP] & 0xff) << 8) 524 | ((rgba[i][RCOMP] & 0xff) ); 525 } 526 } 527 else if (format == GL_BGRA) { 528 GLuint *dst = (GLuint *) destination; 529 GLuint i; 530 for (i = 0; i < n; i++) { 531 dst[i] = ((rgba[i][ACOMP] & 0xff) << 24) 532 | ((rgba[i][RCOMP] & 0xff) << 16) 533 | ((rgba[i][GCOMP] & 0xff) << 8) 534 | ((rgba[i][BCOMP] & 0xff) ); 535 } 536 } 537 else { 538 GLuint *dst = (GLuint *) destination; 539 GLuint i; 540 ASSERT(format == GL_ABGR_EXT); 541 for (i = 0; i < n; i++) { 542 dst[i] = ((rgba[i][RCOMP] & 0xff) << 24) 543 | ((rgba[i][GCOMP] & 0xff) << 16) 544 | ((rgba[i][BCOMP] & 0xff) << 8) 545 | ((rgba[i][ACOMP] & 0xff) ); 546 } 547 } 548 break; 549 case GL_UNSIGNED_INT_10_10_10_2: 550 if (format == GL_RGBA) { 551 GLuint *dst = (GLuint *) destination; 552 GLuint i; 553 for (i = 0; i < n; i++) { 554 dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22) 555 | ((rgba[i][GCOMP] & 0x3ff) << 12) 556 | ((rgba[i][BCOMP] & 0x3ff) << 2) 557 | ((rgba[i][ACOMP] & 0x3) ); 558 } 559 } 560 else if (format == GL_BGRA) { 561 GLuint *dst = (GLuint *) destination; 562 GLuint i; 563 for (i = 0; i < n; i++) { 564 dst[i] = ((rgba[i][BCOMP] & 0x3ff) << 22) 565 | ((rgba[i][GCOMP] & 0x3ff) << 12) 566 | ((rgba[i][RCOMP] & 0x3ff) << 2) 567 | ((rgba[i][ACOMP] & 0x3) ); 568 } 569 } 570 else { 571 GLuint *dst = (GLuint *) destination; 572 GLuint i; 573 ASSERT(format == GL_ABGR_EXT); 574 for (i = 0; i < n; i++) { 575 dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22) 576 | ((rgba[i][BCOMP] & 0x3ff) << 12) 577 | ((rgba[i][GCOMP] & 0x3ff) << 2) 578 | ((rgba[i][RCOMP] & 0x3) ); 579 } 580 } 581 break; 582 case GL_UNSIGNED_INT_2_10_10_10_REV: 583 if (format == GL_RGBA) { 584 GLuint *dst = (GLuint *) destination; 585 GLuint i; 586 for (i = 0; i < n; i++) { 587 dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22) 588 | ((rgba[i][BCOMP] & 0x3ff) << 12) 589 | ((rgba[i][GCOMP] & 0x3ff) << 2) 590 | ((rgba[i][RCOMP] & 0x3) ); 591 } 592 } 593 else if (format == GL_BGRA) { 594 GLuint *dst = (GLuint *) destination; 595 GLuint i; 596 for (i = 0; i < n; i++) { 597 dst[i] = ((rgba[i][ACOMP] & 0x3ff) << 22) 598 | ((rgba[i][RCOMP] & 0x3ff) << 12) 599 | ((rgba[i][GCOMP] & 0x3ff) << 2) 600 | ((rgba[i][BCOMP] & 0x3) ); 601 } 602 } 603 else { 604 GLuint *dst = (GLuint *) destination; 605 GLuint i; 606 ASSERT(format == GL_ABGR_EXT); 607 for (i = 0; i < n; i++) { 608 dst[i] = ((rgba[i][RCOMP] & 0x3ff) << 22) 609 | ((rgba[i][GCOMP] & 0x3ff) << 12) 610 | ((rgba[i][BCOMP] & 0x3ff) << 2) 611 | ((rgba[i][ACOMP] & 0x3) ); 612 } 613 } 614 break; 615 default: 616 _mesa_problem(ctx, "Bad type in pack_histogram"); 617 } 618 619#undef PACK_MACRO 620} 621 622 623/* 624 * Given an internalFormat token passed to glHistogram or glMinMax, 625 * return the corresponding base format. 626 * Return -1 if invalid token. 627 */ 628static GLint 629base_histogram_format( GLenum format ) 630{ 631 switch (format) { 632 case GL_ALPHA: 633 case GL_ALPHA4: 634 case GL_ALPHA8: 635 case GL_ALPHA12: 636 case GL_ALPHA16: 637 return GL_ALPHA; 638 case GL_LUMINANCE: 639 case GL_LUMINANCE4: 640 case GL_LUMINANCE8: 641 case GL_LUMINANCE12: 642 case GL_LUMINANCE16: 643 return GL_LUMINANCE; 644 case GL_LUMINANCE_ALPHA: 645 case GL_LUMINANCE4_ALPHA4: 646 case GL_LUMINANCE6_ALPHA2: 647 case GL_LUMINANCE8_ALPHA8: 648 case GL_LUMINANCE12_ALPHA4: 649 case GL_LUMINANCE12_ALPHA12: 650 case GL_LUMINANCE16_ALPHA16: 651 return GL_LUMINANCE_ALPHA; 652 case GL_RGB: 653 case GL_R3_G3_B2: 654 case GL_RGB4: 655 case GL_RGB5: 656 case GL_RGB8: 657 case GL_RGB10: 658 case GL_RGB12: 659 case GL_RGB16: 660 return GL_RGB; 661 case GL_RGBA: 662 case GL_RGBA2: 663 case GL_RGBA4: 664 case GL_RGB5_A1: 665 case GL_RGBA8: 666 case GL_RGB10_A2: 667 case GL_RGBA12: 668 case GL_RGBA16: 669 return GL_RGBA; 670 default: 671 return -1; /* error */ 672 } 673} 674 675 676 677/********************************************************************** 678 * API functions 679 */ 680 681 682void GLAPIENTRY 683_mesa_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) 684{ 685 GET_CURRENT_CONTEXT(ctx); 686 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 687 688 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 689 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax"); 690 return; 691 } 692 693 if (target != GL_MINMAX) { 694 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmax(target)"); 695 return; 696 } 697 698 if (format != GL_RED && 699 format != GL_GREEN && 700 format != GL_BLUE && 701 format != GL_ALPHA && 702 format != GL_RGB && 703 format != GL_BGR && 704 format != GL_RGBA && 705 format != GL_BGRA && 706 format != GL_ABGR_EXT && 707 format != GL_LUMINANCE && 708 format != GL_LUMINANCE_ALPHA) { 709 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMax(format)"); 710 } 711 712 if (!_mesa_is_legal_format_and_type(ctx, format, type)) { 713 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmax(format or type)"); 714 return; 715 } 716 717 if (ctx->Pack.BufferObj->Name) { 718 /* pack min/max values into a PBO */ 719 GLubyte *buf; 720 if (!_mesa_validate_pbo_access(1, &ctx->Pack, 2, 1, 1, 721 format, type, values)) { 722 _mesa_error(ctx, GL_INVALID_OPERATION, 723 "glGetMinMax(invalid PBO access)"); 724 return; 725 } 726 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, 727 GL_WRITE_ONLY_ARB, 728 ctx->Pack.BufferObj); 729 if (!buf) { 730 /* buffer is already mapped - that's an error */ 731 _mesa_error(ctx, GL_INVALID_OPERATION,"glGetMinMax(PBO is mapped)"); 732 return; 733 } 734 values = ADD_POINTERS(buf, values); 735 } 736 else if (!values) { 737 /* not an error */ 738 return; 739 } 740 741 { 742 GLfloat minmax[2][4]; 743 minmax[0][RCOMP] = CLAMP(ctx->MinMax.Min[RCOMP], 0.0F, 1.0F); 744 minmax[0][GCOMP] = CLAMP(ctx->MinMax.Min[GCOMP], 0.0F, 1.0F); 745 minmax[0][BCOMP] = CLAMP(ctx->MinMax.Min[BCOMP], 0.0F, 1.0F); 746 minmax[0][ACOMP] = CLAMP(ctx->MinMax.Min[ACOMP], 0.0F, 1.0F); 747 minmax[1][RCOMP] = CLAMP(ctx->MinMax.Max[RCOMP], 0.0F, 1.0F); 748 minmax[1][GCOMP] = CLAMP(ctx->MinMax.Max[GCOMP], 0.0F, 1.0F); 749 minmax[1][BCOMP] = CLAMP(ctx->MinMax.Max[BCOMP], 0.0F, 1.0F); 750 minmax[1][ACOMP] = CLAMP(ctx->MinMax.Max[ACOMP], 0.0F, 1.0F); 751 _mesa_pack_rgba_span_float(ctx, 2, minmax, 752 format, type, values, &ctx->Pack, 0x0); 753 } 754 755 if (ctx->Pack.BufferObj->Name) { 756 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, 757 ctx->Pack.BufferObj); 758 } 759 760 if (reset) { 761 _mesa_ResetMinmax(GL_MINMAX); 762 } 763} 764 765 766void GLAPIENTRY 767_mesa_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) 768{ 769 GET_CURRENT_CONTEXT(ctx); 770 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 771 772 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 773 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram"); 774 return; 775 } 776 777 if (target != GL_HISTOGRAM) { 778 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(target)"); 779 return; 780 } 781 782 if (format != GL_RED && 783 format != GL_GREEN && 784 format != GL_BLUE && 785 format != GL_ALPHA && 786 format != GL_RGB && 787 format != GL_BGR && 788 format != GL_RGBA && 789 format != GL_BGRA && 790 format != GL_ABGR_EXT && 791 format != GL_LUMINANCE && 792 format != GL_LUMINANCE_ALPHA) { 793 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogram(format)"); 794 } 795 796 if (!_mesa_is_legal_format_and_type(ctx, format, type)) { 797 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogram(format or type)"); 798 return; 799 } 800 801 if (ctx->Pack.BufferObj->Name) { 802 /* pack min/max values into a PBO */ 803 GLubyte *buf; 804 if (!_mesa_validate_pbo_access(1, &ctx->Pack, ctx->Histogram.Width, 1, 1, 805 format, type, values)) { 806 _mesa_error(ctx, GL_INVALID_OPERATION, 807 "glGetHistogram(invalid PBO access)"); 808 return; 809 } 810 buf = (GLubyte *) ctx->Driver.MapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, 811 GL_WRITE_ONLY_ARB, 812 ctx->Pack.BufferObj); 813 if (!buf) { 814 /* buffer is already mapped - that's an error */ 815 _mesa_error(ctx,GL_INVALID_OPERATION,"glGetHistogram(PBO is mapped)"); 816 return; 817 } 818 values = ADD_POINTERS(buf, values); 819 } 820 else if (!values) { 821 /* not an error */ 822 return; 823 } 824 825 pack_histogram(ctx, ctx->Histogram.Width, 826 (CONST GLuint (*)[4]) ctx->Histogram.Count, 827 format, type, values, &ctx->Pack); 828 829 if (ctx->Pack.BufferObj->Name) { 830 ctx->Driver.UnmapBuffer(ctx, GL_PIXEL_PACK_BUFFER_EXT, 831 ctx->Pack.BufferObj); 832 } 833 834 if (reset) { 835 GLuint i; 836 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) { 837 ctx->Histogram.Count[i][0] = 0; 838 ctx->Histogram.Count[i][1] = 0; 839 ctx->Histogram.Count[i][2] = 0; 840 ctx->Histogram.Count[i][3] = 0; 841 } 842 } 843} 844 845 846void GLAPIENTRY 847_mesa_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params) 848{ 849 GET_CURRENT_CONTEXT(ctx); 850 ASSERT_OUTSIDE_BEGIN_END(ctx); 851 852 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 853 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameterfv"); 854 return; 855 } 856 857 if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) { 858 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(target)"); 859 return; 860 } 861 862 switch (pname) { 863 case GL_HISTOGRAM_WIDTH: 864 *params = (GLfloat) ctx->Histogram.Width; 865 break; 866 case GL_HISTOGRAM_FORMAT: 867 *params = (GLfloat) ctx->Histogram.Format; 868 break; 869 case GL_HISTOGRAM_RED_SIZE: 870 *params = (GLfloat) ctx->Histogram.RedSize; 871 break; 872 case GL_HISTOGRAM_GREEN_SIZE: 873 *params = (GLfloat) ctx->Histogram.GreenSize; 874 break; 875 case GL_HISTOGRAM_BLUE_SIZE: 876 *params = (GLfloat) ctx->Histogram.BlueSize; 877 break; 878 case GL_HISTOGRAM_ALPHA_SIZE: 879 *params = (GLfloat) ctx->Histogram.AlphaSize; 880 break; 881 case GL_HISTOGRAM_LUMINANCE_SIZE: 882 *params = (GLfloat) ctx->Histogram.LuminanceSize; 883 break; 884 case GL_HISTOGRAM_SINK: 885 *params = (GLfloat) ctx->Histogram.Sink; 886 break; 887 default: 888 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameterfv(pname)"); 889 } 890} 891 892 893void GLAPIENTRY 894_mesa_GetHistogramParameteriv(GLenum target, GLenum pname, GLint *params) 895{ 896 GET_CURRENT_CONTEXT(ctx); 897 ASSERT_OUTSIDE_BEGIN_END(ctx); 898 899 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 900 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetHistogramParameteriv"); 901 return; 902 } 903 904 if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) { 905 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(target)"); 906 return; 907 } 908 909 switch (pname) { 910 case GL_HISTOGRAM_WIDTH: 911 *params = (GLint) ctx->Histogram.Width; 912 break; 913 case GL_HISTOGRAM_FORMAT: 914 *params = (GLint) ctx->Histogram.Format; 915 break; 916 case GL_HISTOGRAM_RED_SIZE: 917 *params = (GLint) ctx->Histogram.RedSize; 918 break; 919 case GL_HISTOGRAM_GREEN_SIZE: 920 *params = (GLint) ctx->Histogram.GreenSize; 921 break; 922 case GL_HISTOGRAM_BLUE_SIZE: 923 *params = (GLint) ctx->Histogram.BlueSize; 924 break; 925 case GL_HISTOGRAM_ALPHA_SIZE: 926 *params = (GLint) ctx->Histogram.AlphaSize; 927 break; 928 case GL_HISTOGRAM_LUMINANCE_SIZE: 929 *params = (GLint) ctx->Histogram.LuminanceSize; 930 break; 931 case GL_HISTOGRAM_SINK: 932 *params = (GLint) ctx->Histogram.Sink; 933 break; 934 default: 935 _mesa_error(ctx, GL_INVALID_ENUM, "glGetHistogramParameteriv(pname)"); 936 } 937} 938 939 940void GLAPIENTRY 941_mesa_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params) 942{ 943 GET_CURRENT_CONTEXT(ctx); 944 ASSERT_OUTSIDE_BEGIN_END(ctx); 945 946 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 947 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameterfv"); 948 return; 949 } 950 if (target != GL_MINMAX) { 951 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameterfv(target)"); 952 return; 953 } 954 if (pname == GL_MINMAX_FORMAT) { 955 *params = (GLfloat) ctx->MinMax.Format; 956 } 957 else if (pname == GL_MINMAX_SINK) { 958 *params = (GLfloat) ctx->MinMax.Sink; 959 } 960 else { 961 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameterfv(pname)"); 962 } 963} 964 965 966void GLAPIENTRY 967_mesa_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params) 968{ 969 GET_CURRENT_CONTEXT(ctx); 970 ASSERT_OUTSIDE_BEGIN_END(ctx); 971 972 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 973 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetMinmaxParameteriv"); 974 return; 975 } 976 if (target != GL_MINMAX) { 977 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinmaxParameteriv(target)"); 978 return; 979 } 980 if (pname == GL_MINMAX_FORMAT) { 981 *params = (GLint) ctx->MinMax.Format; 982 } 983 else if (pname == GL_MINMAX_SINK) { 984 *params = (GLint) ctx->MinMax.Sink; 985 } 986 else { 987 _mesa_error(ctx, GL_INVALID_ENUM, "glGetMinMaxParameteriv(pname)"); 988 } 989} 990 991 992void GLAPIENTRY 993_mesa_Histogram(GLenum target, GLsizei width, GLenum internalFormat, GLboolean sink) 994{ 995 GLuint i; 996 GLboolean error = GL_FALSE; 997 GET_CURRENT_CONTEXT(ctx); 998 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */ 999 1000 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 1001 _mesa_error(ctx, GL_INVALID_OPERATION, "glHistogram"); 1002 return; 1003 } 1004 1005 if (target != GL_HISTOGRAM && target != GL_PROXY_HISTOGRAM) { 1006 _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(target)"); 1007 return; 1008 } 1009 1010 if (width < 0 || width > HISTOGRAM_TABLE_SIZE) { 1011 if (target == GL_PROXY_HISTOGRAM) { 1012 error = GL_TRUE; 1013 } 1014 else { 1015 if (width < 0) 1016 _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)"); 1017 else 1018 _mesa_error(ctx, GL_TABLE_TOO_LARGE, "glHistogram(width)"); 1019 return; 1020 } 1021 } 1022 1023 if (width != 0 && _mesa_bitcount(width) != 1) { 1024 if (target == GL_PROXY_HISTOGRAM) { 1025 error = GL_TRUE; 1026 } 1027 else { 1028 _mesa_error(ctx, GL_INVALID_VALUE, "glHistogram(width)"); 1029 return; 1030 } 1031 } 1032 1033 if (base_histogram_format(internalFormat) < 0) { 1034 if (target == GL_PROXY_HISTOGRAM) { 1035 error = GL_TRUE; 1036 } 1037 else { 1038 _mesa_error(ctx, GL_INVALID_ENUM, "glHistogram(internalFormat)"); 1039 return; 1040 } 1041 } 1042 1043 /* reset histograms */ 1044 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) { 1045 ctx->Histogram.Count[i][0] = 0; 1046 ctx->Histogram.Count[i][1] = 0; 1047 ctx->Histogram.Count[i][2] = 0; 1048 ctx->Histogram.Count[i][3] = 0; 1049 } 1050 1051 if (error) { 1052 ctx->Histogram.Width = 0; 1053 ctx->Histogram.Format = 0; 1054 ctx->Histogram.RedSize = 0; 1055 ctx->Histogram.GreenSize = 0; 1056 ctx->Histogram.BlueSize = 0; 1057 ctx->Histogram.AlphaSize = 0; 1058 ctx->Histogram.LuminanceSize = 0; 1059 } 1060 else { 1061 ctx->Histogram.Width = width; 1062 ctx->Histogram.Format = internalFormat; 1063 ctx->Histogram.Sink = sink; 1064 ctx->Histogram.RedSize = 8 * sizeof(GLuint); 1065 ctx->Histogram.GreenSize = 8 * sizeof(GLuint); 1066 ctx->Histogram.BlueSize = 8 * sizeof(GLuint); 1067 ctx->Histogram.AlphaSize = 8 * sizeof(GLuint); 1068 ctx->Histogram.LuminanceSize = 8 * sizeof(GLuint); 1069 } 1070 1071 ctx->NewState |= _NEW_PIXEL; 1072} 1073 1074 1075void GLAPIENTRY 1076_mesa_Minmax(GLenum target, GLenum internalFormat, GLboolean sink) 1077{ 1078 GET_CURRENT_CONTEXT(ctx); 1079 ASSERT_OUTSIDE_BEGIN_END(ctx); 1080 1081 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 1082 _mesa_error(ctx, GL_INVALID_OPERATION, "glMinmax"); 1083 return; 1084 } 1085 1086 if (target != GL_MINMAX) { 1087 _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(target)"); 1088 return; 1089 } 1090 1091 if (base_histogram_format(internalFormat) < 0) { 1092 _mesa_error(ctx, GL_INVALID_ENUM, "glMinMax(internalFormat)"); 1093 return; 1094 } 1095 1096 if (ctx->MinMax.Sink == sink) 1097 return; 1098 FLUSH_VERTICES(ctx, _NEW_PIXEL); 1099 ctx->MinMax.Sink = sink; 1100} 1101 1102 1103void GLAPIENTRY 1104_mesa_ResetHistogram(GLenum target) 1105{ 1106 GLuint i; 1107 GET_CURRENT_CONTEXT(ctx); 1108 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* sideeffects */ 1109 1110 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 1111 _mesa_error(ctx, GL_INVALID_OPERATION, "glResetHistogram"); 1112 return; 1113 } 1114 1115 if (target != GL_HISTOGRAM) { 1116 _mesa_error(ctx, GL_INVALID_ENUM, "glResetHistogram(target)"); 1117 return; 1118 } 1119 1120 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) { 1121 ctx->Histogram.Count[i][0] = 0; 1122 ctx->Histogram.Count[i][1] = 0; 1123 ctx->Histogram.Count[i][2] = 0; 1124 ctx->Histogram.Count[i][3] = 0; 1125 } 1126 1127 ctx->NewState |= _NEW_PIXEL; 1128} 1129 1130 1131void GLAPIENTRY 1132_mesa_ResetMinmax(GLenum target) 1133{ 1134 GET_CURRENT_CONTEXT(ctx); 1135 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); 1136 1137 if (!ctx->Extensions.EXT_histogram && !ctx->Extensions.ARB_imaging) { 1138 _mesa_error(ctx, GL_INVALID_OPERATION, "glResetMinmax"); 1139 return; 1140 } 1141 1142 if (target != GL_MINMAX) { 1143 _mesa_error(ctx, GL_INVALID_ENUM, "glResetMinMax(target)"); 1144 return; 1145 } 1146 1147 ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000; 1148 ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000; 1149 ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000; 1150 ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000; 1151 ctx->NewState |= _NEW_PIXEL; 1152} 1153 1154 1155 1156/**********************************************************************/ 1157/***** Initialization *****/ 1158/**********************************************************************/ 1159 1160void _mesa_init_histogram( GLcontext * ctx ) 1161{ 1162 int i; 1163 1164 /* Histogram group */ 1165 ctx->Histogram.Width = 0; 1166 ctx->Histogram.Format = GL_RGBA; 1167 ctx->Histogram.Sink = GL_FALSE; 1168 ctx->Histogram.RedSize = 0; 1169 ctx->Histogram.GreenSize = 0; 1170 ctx->Histogram.BlueSize = 0; 1171 ctx->Histogram.AlphaSize = 0; 1172 ctx->Histogram.LuminanceSize = 0; 1173 for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) { 1174 ctx->Histogram.Count[i][0] = 0; 1175 ctx->Histogram.Count[i][1] = 0; 1176 ctx->Histogram.Count[i][2] = 0; 1177 ctx->Histogram.Count[i][3] = 0; 1178 } 1179 1180 /* Min/Max group */ 1181 ctx->MinMax.Format = GL_RGBA; 1182 ctx->MinMax.Sink = GL_FALSE; 1183 ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000; 1184 ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000; 1185 ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000; 1186 ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000; 1187} 1188