image.c revision 0b6dd750584c8e03aa14968d6efdf393e7c8c8f0
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.5 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included 16 * in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27/** 28 * \file image.c 29 * Image handling. 30 */ 31 32 33#include "glheader.h" 34#include "colormac.h" 35#include "image.h" 36#include "imports.h" 37#include "macros.h" 38#include "mfeatures.h" 39#include "mtypes.h" 40 41 42/** 43 * NOTE: 44 * Normally, BYTE_TO_FLOAT(0) returns 0.00392 That causes problems when 45 * we later convert the float to a packed integer value (such as for 46 * GL_RGB5_A1) because we'll wind up with a non-zero value. 47 * 48 * We redefine the macros here so zero is handled correctly. 49 */ 50#undef BYTE_TO_FLOAT 51#define BYTE_TO_FLOAT(B) ((B) == 0 ? 0.0F : ((2.0F * (B) + 1.0F) * (1.0F/255.0F))) 52 53#undef SHORT_TO_FLOAT 54#define SHORT_TO_FLOAT(S) ((S) == 0 ? 0.0F : ((2.0F * (S) + 1.0F) * (1.0F/65535.0F))) 55 56 57 58/** Compute ceiling of integer quotient of A divided by B. */ 59#define CEILING( A, B ) ( (A) % (B) == 0 ? (A)/(B) : (A)/(B)+1 ) 60 61 62/** 63 * \return GL_TRUE if type is packed pixel type, GL_FALSE otherwise. 64 */ 65GLboolean 66_mesa_type_is_packed(GLenum type) 67{ 68 switch (type) { 69 case GL_UNSIGNED_BYTE_3_3_2: 70 case GL_UNSIGNED_BYTE_2_3_3_REV: 71 case MESA_UNSIGNED_BYTE_4_4: 72 case GL_UNSIGNED_SHORT_5_6_5: 73 case GL_UNSIGNED_SHORT_5_6_5_REV: 74 case GL_UNSIGNED_SHORT_4_4_4_4: 75 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 76 case GL_UNSIGNED_SHORT_5_5_5_1: 77 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 78 case GL_UNSIGNED_INT_8_8_8_8: 79 case GL_UNSIGNED_INT_8_8_8_8_REV: 80 case GL_UNSIGNED_INT_10_10_10_2: 81 case GL_UNSIGNED_INT_2_10_10_10_REV: 82 case GL_UNSIGNED_SHORT_8_8_MESA: 83 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 84 case GL_UNSIGNED_INT_24_8_EXT: 85 case GL_UNSIGNED_INT_5_9_9_9_REV: 86 case GL_UNSIGNED_INT_10F_11F_11F_REV: 87 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 88 return GL_TRUE; 89 } 90 91 return GL_FALSE; 92} 93 94 95 96/** 97 * Flip the order of the 2 bytes in each word in the given array. 98 * 99 * \param p array. 100 * \param n number of words. 101 */ 102void 103_mesa_swap2( GLushort *p, GLuint n ) 104{ 105 GLuint i; 106 for (i = 0; i < n; i++) { 107 p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00); 108 } 109} 110 111 112 113/* 114 * Flip the order of the 4 bytes in each word in the given array. 115 */ 116void 117_mesa_swap4( GLuint *p, GLuint n ) 118{ 119 GLuint i, a, b; 120 for (i = 0; i < n; i++) { 121 b = p[i]; 122 a = (b >> 24) 123 | ((b >> 8) & 0xff00) 124 | ((b << 8) & 0xff0000) 125 | ((b << 24) & 0xff000000); 126 p[i] = a; 127 } 128} 129 130 131/** 132 * Get the size of a GL data type. 133 * 134 * \param type GL data type. 135 * 136 * \return the size, in bytes, of the given data type, 0 if a GL_BITMAP, or -1 137 * if an invalid type enum. 138 */ 139GLint 140_mesa_sizeof_type( GLenum type ) 141{ 142 switch (type) { 143 case GL_BITMAP: 144 return 0; 145 case GL_UNSIGNED_BYTE: 146 return sizeof(GLubyte); 147 case GL_BYTE: 148 return sizeof(GLbyte); 149 case GL_UNSIGNED_SHORT: 150 return sizeof(GLushort); 151 case GL_SHORT: 152 return sizeof(GLshort); 153 case GL_UNSIGNED_INT: 154 return sizeof(GLuint); 155 case GL_INT: 156 return sizeof(GLint); 157 case GL_FLOAT: 158 return sizeof(GLfloat); 159 case GL_DOUBLE: 160 return sizeof(GLdouble); 161 case GL_HALF_FLOAT_ARB: 162 return sizeof(GLhalfARB); 163 case GL_FIXED: 164 return sizeof(GLfixed); 165 default: 166 return -1; 167 } 168} 169 170 171/** 172 * Same as _mesa_sizeof_type() but also accepting the packed pixel 173 * format data types. 174 */ 175GLint 176_mesa_sizeof_packed_type( GLenum type ) 177{ 178 switch (type) { 179 case GL_BITMAP: 180 return 0; 181 case GL_UNSIGNED_BYTE: 182 return sizeof(GLubyte); 183 case GL_BYTE: 184 return sizeof(GLbyte); 185 case GL_UNSIGNED_SHORT: 186 return sizeof(GLushort); 187 case GL_SHORT: 188 return sizeof(GLshort); 189 case GL_UNSIGNED_INT: 190 return sizeof(GLuint); 191 case GL_INT: 192 return sizeof(GLint); 193 case GL_HALF_FLOAT_ARB: 194 return sizeof(GLhalfARB); 195 case GL_FLOAT: 196 return sizeof(GLfloat); 197 case GL_UNSIGNED_BYTE_3_3_2: 198 return sizeof(GLubyte); 199 case GL_UNSIGNED_BYTE_2_3_3_REV: 200 return sizeof(GLubyte); 201 case MESA_UNSIGNED_BYTE_4_4: 202 return sizeof(GLubyte); 203 case GL_UNSIGNED_SHORT_5_6_5: 204 return sizeof(GLushort); 205 case GL_UNSIGNED_SHORT_5_6_5_REV: 206 return sizeof(GLushort); 207 case GL_UNSIGNED_SHORT_4_4_4_4: 208 return sizeof(GLushort); 209 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 210 return sizeof(GLushort); 211 case GL_UNSIGNED_SHORT_5_5_5_1: 212 return sizeof(GLushort); 213 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 214 return sizeof(GLushort); 215 case GL_UNSIGNED_INT_8_8_8_8: 216 return sizeof(GLuint); 217 case GL_UNSIGNED_INT_8_8_8_8_REV: 218 return sizeof(GLuint); 219 case GL_UNSIGNED_INT_10_10_10_2: 220 return sizeof(GLuint); 221 case GL_UNSIGNED_INT_2_10_10_10_REV: 222 return sizeof(GLuint); 223 case GL_UNSIGNED_SHORT_8_8_MESA: 224 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 225 return sizeof(GLushort); 226 case GL_UNSIGNED_INT_24_8_EXT: 227 return sizeof(GLuint); 228 case GL_UNSIGNED_INT_5_9_9_9_REV: 229 return sizeof(GLuint); 230 case GL_UNSIGNED_INT_10F_11F_11F_REV: 231 return sizeof(GLuint); 232 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 233 return 8; 234 default: 235 return -1; 236 } 237} 238 239 240/** 241 * Get the number of components in a pixel format. 242 * 243 * \param format pixel format. 244 * 245 * \return the number of components in the given format, or -1 if a bad format. 246 */ 247GLint 248_mesa_components_in_format( GLenum format ) 249{ 250 switch (format) { 251 case GL_COLOR_INDEX: 252 case GL_STENCIL_INDEX: 253 case GL_DEPTH_COMPONENT: 254 case GL_RED: 255 case GL_RED_INTEGER_EXT: 256 case GL_GREEN: 257 case GL_GREEN_INTEGER_EXT: 258 case GL_BLUE: 259 case GL_BLUE_INTEGER_EXT: 260 case GL_ALPHA: 261 case GL_ALPHA_INTEGER_EXT: 262 case GL_LUMINANCE: 263 case GL_LUMINANCE_INTEGER_EXT: 264 case GL_INTENSITY: 265 return 1; 266 case GL_LUMINANCE_ALPHA: 267 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 268 case GL_RG: 269 return 2; 270 case GL_RGB: 271 case GL_RGB_INTEGER_EXT: 272 return 3; 273 case GL_RGBA: 274 case GL_RGBA_INTEGER_EXT: 275 return 4; 276 case GL_BGR: 277 return 3; 278 case GL_BGRA: 279 return 4; 280 case GL_ABGR_EXT: 281 return 4; 282 case GL_YCBCR_MESA: 283 return 2; 284 case GL_DEPTH_STENCIL_EXT: 285 return 2; 286 case GL_DUDV_ATI: 287 case GL_DU8DV8_ATI: 288 return 2; 289 default: 290 return -1; 291 } 292} 293 294 295/** 296 * Get the bytes per pixel of pixel format type pair. 297 * 298 * \param format pixel format. 299 * \param type pixel type. 300 * 301 * \return bytes per pixel, or -1 if a bad format or type was given. 302 */ 303GLint 304_mesa_bytes_per_pixel( GLenum format, GLenum type ) 305{ 306 GLint comps = _mesa_components_in_format( format ); 307 if (comps < 0) 308 return -1; 309 310 switch (type) { 311 case GL_BITMAP: 312 return 0; /* special case */ 313 case GL_BYTE: 314 case GL_UNSIGNED_BYTE: 315 return comps * sizeof(GLubyte); 316 case GL_SHORT: 317 case GL_UNSIGNED_SHORT: 318 return comps * sizeof(GLshort); 319 case GL_INT: 320 case GL_UNSIGNED_INT: 321 return comps * sizeof(GLint); 322 case GL_FLOAT: 323 return comps * sizeof(GLfloat); 324 case GL_HALF_FLOAT_ARB: 325 return comps * sizeof(GLhalfARB); 326 case GL_UNSIGNED_BYTE_3_3_2: 327 case GL_UNSIGNED_BYTE_2_3_3_REV: 328 if (format == GL_RGB || format == GL_BGR || 329 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) 330 return sizeof(GLubyte); 331 else 332 return -1; /* error */ 333 case GL_UNSIGNED_SHORT_5_6_5: 334 case GL_UNSIGNED_SHORT_5_6_5_REV: 335 if (format == GL_RGB || format == GL_BGR || 336 format == GL_RGB_INTEGER_EXT || format == GL_BGR_INTEGER_EXT) 337 return sizeof(GLushort); 338 else 339 return -1; /* error */ 340 case GL_UNSIGNED_SHORT_4_4_4_4: 341 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 342 case GL_UNSIGNED_SHORT_5_5_5_1: 343 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 344 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || 345 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) 346 return sizeof(GLushort); 347 else 348 return -1; 349 case GL_UNSIGNED_INT_8_8_8_8: 350 case GL_UNSIGNED_INT_8_8_8_8_REV: 351 case GL_UNSIGNED_INT_10_10_10_2: 352 case GL_UNSIGNED_INT_2_10_10_10_REV: 353 if (format == GL_RGBA || format == GL_BGRA || format == GL_ABGR_EXT || 354 format == GL_RGBA_INTEGER_EXT || format == GL_BGRA_INTEGER_EXT) 355 return sizeof(GLuint); 356 else 357 return -1; 358 case GL_UNSIGNED_SHORT_8_8_MESA: 359 case GL_UNSIGNED_SHORT_8_8_REV_MESA: 360 if (format == GL_YCBCR_MESA) 361 return sizeof(GLushort); 362 else 363 return -1; 364 case GL_UNSIGNED_INT_24_8_EXT: 365 if (format == GL_DEPTH_STENCIL_EXT) 366 return sizeof(GLuint); 367 else 368 return -1; 369 case GL_UNSIGNED_INT_5_9_9_9_REV: 370 if (format == GL_RGB) 371 return sizeof(GLuint); 372 else 373 return -1; 374 case GL_UNSIGNED_INT_10F_11F_11F_REV: 375 if (format == GL_RGB) 376 return sizeof(GLuint); 377 else 378 return -1; 379 case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: 380 if (format == GL_DEPTH_STENCIL) 381 return 8; 382 else 383 return -1; 384 default: 385 return -1; 386 } 387} 388 389 390/** 391 * Test for a legal pixel format and type. 392 * 393 * \param format pixel format. 394 * \param type pixel type. 395 * 396 * \return GL_TRUE if the given pixel format and type are legal, or GL_FALSE 397 * otherwise. 398 */ 399GLboolean 400_mesa_is_legal_format_and_type(const struct gl_context *ctx, 401 GLenum format, GLenum type) 402{ 403 switch (format) { 404 case GL_COLOR_INDEX: 405 case GL_STENCIL_INDEX: 406 switch (type) { 407 case GL_BITMAP: 408 case GL_BYTE: 409 case GL_UNSIGNED_BYTE: 410 case GL_SHORT: 411 case GL_UNSIGNED_SHORT: 412 case GL_INT: 413 case GL_UNSIGNED_INT: 414 case GL_FLOAT: 415 return GL_TRUE; 416 case GL_HALF_FLOAT_ARB: 417 return ctx->Extensions.ARB_half_float_pixel; 418 default: 419 return GL_FALSE; 420 } 421 case GL_RED: 422 case GL_GREEN: 423 case GL_BLUE: 424 case GL_ALPHA: 425#if 0 /* not legal! see table 3.6 of the 1.5 spec */ 426 case GL_INTENSITY: 427#endif 428 case GL_LUMINANCE: 429 case GL_LUMINANCE_ALPHA: 430 case GL_DEPTH_COMPONENT: 431 switch (type) { 432 case GL_BYTE: 433 case GL_UNSIGNED_BYTE: 434 case GL_SHORT: 435 case GL_UNSIGNED_SHORT: 436 case GL_INT: 437 case GL_UNSIGNED_INT: 438 case GL_FLOAT: 439 return GL_TRUE; 440 case GL_HALF_FLOAT_ARB: 441 return ctx->Extensions.ARB_half_float_pixel; 442 default: 443 return GL_FALSE; 444 } 445 case GL_RG: 446 if (!ctx->Extensions.ARB_texture_rg) 447 return GL_FALSE; 448 449 switch (type) { 450 case GL_BYTE: 451 case GL_UNSIGNED_BYTE: 452 case GL_SHORT: 453 case GL_UNSIGNED_SHORT: 454 case GL_INT: 455 case GL_UNSIGNED_INT: 456 case GL_FLOAT: 457 return GL_TRUE; 458 case GL_HALF_FLOAT_ARB: 459 return ctx->Extensions.ARB_half_float_pixel; 460 default: 461 return GL_FALSE; 462 } 463 case GL_RGB: 464 switch (type) { 465 case GL_BYTE: 466 case GL_UNSIGNED_BYTE: 467 case GL_SHORT: 468 case GL_UNSIGNED_SHORT: 469 case GL_INT: 470 case GL_UNSIGNED_INT: 471 case GL_FLOAT: 472 case GL_UNSIGNED_BYTE_3_3_2: 473 case GL_UNSIGNED_BYTE_2_3_3_REV: 474 case GL_UNSIGNED_SHORT_5_6_5: 475 case GL_UNSIGNED_SHORT_5_6_5_REV: 476 return GL_TRUE; 477 case GL_HALF_FLOAT_ARB: 478 return ctx->Extensions.ARB_half_float_pixel; 479 case GL_UNSIGNED_INT_5_9_9_9_REV: 480 return ctx->Extensions.EXT_texture_shared_exponent; 481 case GL_UNSIGNED_INT_10F_11F_11F_REV: 482 return ctx->Extensions.EXT_packed_float; 483 default: 484 return GL_FALSE; 485 } 486 case GL_BGR: 487 switch (type) { 488 /* NOTE: no packed types are supported with BGR. That's 489 * intentional, according to the GL spec. 490 */ 491 case GL_BYTE: 492 case GL_UNSIGNED_BYTE: 493 case GL_SHORT: 494 case GL_UNSIGNED_SHORT: 495 case GL_INT: 496 case GL_UNSIGNED_INT: 497 case GL_FLOAT: 498 return GL_TRUE; 499 case GL_HALF_FLOAT_ARB: 500 return ctx->Extensions.ARB_half_float_pixel; 501 default: 502 return GL_FALSE; 503 } 504 case GL_RGBA: 505 case GL_BGRA: 506 case GL_ABGR_EXT: 507 switch (type) { 508 case GL_BYTE: 509 case GL_UNSIGNED_BYTE: 510 case GL_SHORT: 511 case GL_UNSIGNED_SHORT: 512 case GL_INT: 513 case GL_UNSIGNED_INT: 514 case GL_FLOAT: 515 case GL_UNSIGNED_SHORT_4_4_4_4: 516 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 517 case GL_UNSIGNED_SHORT_5_5_5_1: 518 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 519 case GL_UNSIGNED_INT_8_8_8_8: 520 case GL_UNSIGNED_INT_8_8_8_8_REV: 521 case GL_UNSIGNED_INT_10_10_10_2: 522 case GL_UNSIGNED_INT_2_10_10_10_REV: 523 return GL_TRUE; 524 case GL_HALF_FLOAT_ARB: 525 return ctx->Extensions.ARB_half_float_pixel; 526 default: 527 return GL_FALSE; 528 } 529 case GL_YCBCR_MESA: 530 if (type == GL_UNSIGNED_SHORT_8_8_MESA || 531 type == GL_UNSIGNED_SHORT_8_8_REV_MESA) 532 return GL_TRUE; 533 else 534 return GL_FALSE; 535 case GL_DEPTH_STENCIL_EXT: 536 if ((ctx->Extensions.EXT_packed_depth_stencil && 537 type == GL_UNSIGNED_INT_24_8_EXT) || 538 (ctx->Extensions.ARB_depth_buffer_float && 539 type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV)) 540 return GL_TRUE; 541 else 542 return GL_FALSE; 543 case GL_DUDV_ATI: 544 case GL_DU8DV8_ATI: 545 switch (type) { 546 case GL_BYTE: 547 case GL_UNSIGNED_BYTE: 548 case GL_SHORT: 549 case GL_UNSIGNED_SHORT: 550 case GL_INT: 551 case GL_UNSIGNED_INT: 552 case GL_FLOAT: 553 return GL_TRUE; 554 default: 555 return GL_FALSE; 556 } 557 558 /* integer-valued formats */ 559 case GL_RED_INTEGER_EXT: 560 case GL_GREEN_INTEGER_EXT: 561 case GL_BLUE_INTEGER_EXT: 562 case GL_ALPHA_INTEGER_EXT: 563 switch (type) { 564 case GL_BYTE: 565 case GL_UNSIGNED_BYTE: 566 case GL_SHORT: 567 case GL_UNSIGNED_SHORT: 568 case GL_INT: 569 case GL_UNSIGNED_INT: 570 return ctx->Extensions.EXT_texture_integer; 571 default: 572 return GL_FALSE; 573 } 574 575 case GL_RGB_INTEGER_EXT: 576 switch (type) { 577 case GL_BYTE: 578 case GL_UNSIGNED_BYTE: 579 case GL_SHORT: 580 case GL_UNSIGNED_SHORT: 581 case GL_INT: 582 case GL_UNSIGNED_INT: 583 case GL_UNSIGNED_BYTE_3_3_2: 584 case GL_UNSIGNED_BYTE_2_3_3_REV: 585 case GL_UNSIGNED_SHORT_5_6_5: 586 case GL_UNSIGNED_SHORT_5_6_5_REV: 587 return ctx->Extensions.EXT_texture_integer; 588 default: 589 return GL_FALSE; 590 } 591 592 case GL_BGR_INTEGER_EXT: 593 switch (type) { 594 case GL_BYTE: 595 case GL_UNSIGNED_BYTE: 596 case GL_SHORT: 597 case GL_UNSIGNED_SHORT: 598 case GL_INT: 599 case GL_UNSIGNED_INT: 600 /* NOTE: no packed formats w/ BGR format */ 601 return ctx->Extensions.EXT_texture_integer; 602 default: 603 return GL_FALSE; 604 } 605 606 case GL_RGBA_INTEGER_EXT: 607 case GL_BGRA_INTEGER_EXT: 608 switch (type) { 609 case GL_BYTE: 610 case GL_UNSIGNED_BYTE: 611 case GL_SHORT: 612 case GL_UNSIGNED_SHORT: 613 case GL_INT: 614 case GL_UNSIGNED_INT: 615 case GL_UNSIGNED_SHORT_4_4_4_4: 616 case GL_UNSIGNED_SHORT_4_4_4_4_REV: 617 case GL_UNSIGNED_SHORT_5_5_5_1: 618 case GL_UNSIGNED_SHORT_1_5_5_5_REV: 619 case GL_UNSIGNED_INT_8_8_8_8: 620 case GL_UNSIGNED_INT_8_8_8_8_REV: 621 case GL_UNSIGNED_INT_10_10_10_2: 622 case GL_UNSIGNED_INT_2_10_10_10_REV: 623 return ctx->Extensions.EXT_texture_integer; 624 default: 625 return GL_FALSE; 626 } 627 628 case GL_LUMINANCE_INTEGER_EXT: 629 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 630 switch (type) { 631 case GL_BYTE: 632 case GL_UNSIGNED_BYTE: 633 case GL_SHORT: 634 case GL_UNSIGNED_SHORT: 635 case GL_INT: 636 case GL_UNSIGNED_INT: 637 return ctx->Extensions.EXT_texture_integer; 638 default: 639 return GL_FALSE; 640 } 641 642 default: 643 ; /* fall-through */ 644 } 645 return GL_FALSE; 646} 647 648 649/** 650 * Test if the given image format is a color/RGBA format (i.e., not color 651 * index, depth, stencil, etc). 652 * \param format the image format value (may by an internal texture format) 653 * \return GL_TRUE if its a color/RGBA format, GL_FALSE otherwise. 654 */ 655GLboolean 656_mesa_is_color_format(GLenum format) 657{ 658 switch (format) { 659 case GL_RED: 660 case GL_GREEN: 661 case GL_BLUE: 662 case GL_ALPHA: 663 case GL_ALPHA4: 664 case GL_ALPHA8: 665 case GL_ALPHA12: 666 case GL_ALPHA16: 667 case 1: 668 case GL_LUMINANCE: 669 case GL_LUMINANCE4: 670 case GL_LUMINANCE8: 671 case GL_LUMINANCE12: 672 case GL_LUMINANCE16: 673 case 2: 674 case GL_LUMINANCE_ALPHA: 675 case GL_LUMINANCE4_ALPHA4: 676 case GL_LUMINANCE6_ALPHA2: 677 case GL_LUMINANCE8_ALPHA8: 678 case GL_LUMINANCE12_ALPHA4: 679 case GL_LUMINANCE12_ALPHA12: 680 case GL_LUMINANCE16_ALPHA16: 681 case GL_INTENSITY: 682 case GL_INTENSITY4: 683 case GL_INTENSITY8: 684 case GL_INTENSITY12: 685 case GL_INTENSITY16: 686 case GL_R8: 687 case GL_R16: 688 case GL_RG: 689 case GL_RG8: 690 case GL_RG16: 691 case 3: 692 case GL_RGB: 693 case GL_BGR: 694 case GL_R3_G3_B2: 695 case GL_RGB4: 696 case GL_RGB5: 697 case GL_RGB8: 698 case GL_RGB10: 699 case GL_RGB12: 700 case GL_RGB16: 701 case 4: 702 case GL_ABGR_EXT: 703 case GL_RGBA: 704 case GL_BGRA: 705 case GL_RGBA2: 706 case GL_RGBA4: 707 case GL_RGB5_A1: 708 case GL_RGBA8: 709 case GL_RGB10_A2: 710 case GL_RGBA12: 711 case GL_RGBA16: 712 /* float texture formats */ 713 case GL_ALPHA16F_ARB: 714 case GL_ALPHA32F_ARB: 715 case GL_LUMINANCE16F_ARB: 716 case GL_LUMINANCE32F_ARB: 717 case GL_LUMINANCE_ALPHA16F_ARB: 718 case GL_LUMINANCE_ALPHA32F_ARB: 719 case GL_INTENSITY16F_ARB: 720 case GL_INTENSITY32F_ARB: 721 case GL_R16F: 722 case GL_R32F: 723 case GL_RG16F: 724 case GL_RG32F: 725 case GL_RGB16F_ARB: 726 case GL_RGB32F_ARB: 727 case GL_RGBA16F_ARB: 728 case GL_RGBA32F_ARB: 729 /* compressed formats */ 730 case GL_COMPRESSED_ALPHA: 731 case GL_COMPRESSED_LUMINANCE: 732 case GL_COMPRESSED_LUMINANCE_ALPHA: 733 case GL_COMPRESSED_INTENSITY: 734 case GL_COMPRESSED_RED: 735 case GL_COMPRESSED_RG: 736 case GL_COMPRESSED_RGB: 737 case GL_COMPRESSED_RGBA: 738 case GL_RGB_S3TC: 739 case GL_RGB4_S3TC: 740 case GL_RGBA_S3TC: 741 case GL_RGBA4_S3TC: 742 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 743 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 744 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: 745 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: 746 case GL_COMPRESSED_RGB_FXT1_3DFX: 747 case GL_COMPRESSED_RGBA_FXT1_3DFX: 748#if FEATURE_EXT_texture_sRGB 749 case GL_SRGB_EXT: 750 case GL_SRGB8_EXT: 751 case GL_SRGB_ALPHA_EXT: 752 case GL_SRGB8_ALPHA8_EXT: 753 case GL_SLUMINANCE_ALPHA_EXT: 754 case GL_SLUMINANCE8_ALPHA8_EXT: 755 case GL_SLUMINANCE_EXT: 756 case GL_SLUMINANCE8_EXT: 757 case GL_COMPRESSED_SRGB_EXT: 758 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: 759 case GL_COMPRESSED_SRGB_ALPHA_EXT: 760 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 761 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 762 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 763 case GL_COMPRESSED_SLUMINANCE_EXT: 764 case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT: 765#endif /* FEATURE_EXT_texture_sRGB */ 766 case GL_COMPRESSED_RED_RGTC1: 767 case GL_COMPRESSED_SIGNED_RED_RGTC1: 768 case GL_COMPRESSED_RG_RGTC2: 769 case GL_COMPRESSED_SIGNED_RG_RGTC2: 770 case GL_COMPRESSED_LUMINANCE_LATC1_EXT: 771 case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: 772 case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: 773 case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: 774 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: 775 /* generic integer formats */ 776 case GL_RED_INTEGER_EXT: 777 case GL_GREEN_INTEGER_EXT: 778 case GL_BLUE_INTEGER_EXT: 779 case GL_ALPHA_INTEGER_EXT: 780 case GL_RGB_INTEGER_EXT: 781 case GL_RGBA_INTEGER_EXT: 782 case GL_BGR_INTEGER_EXT: 783 case GL_BGRA_INTEGER_EXT: 784 case GL_LUMINANCE_INTEGER_EXT: 785 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 786 /* sized integer formats */ 787 case GL_RGBA32UI_EXT: 788 case GL_RGB32UI_EXT: 789 case GL_ALPHA32UI_EXT: 790 case GL_INTENSITY32UI_EXT: 791 case GL_LUMINANCE32UI_EXT: 792 case GL_LUMINANCE_ALPHA32UI_EXT: 793 case GL_RGBA16UI_EXT: 794 case GL_RGB16UI_EXT: 795 case GL_ALPHA16UI_EXT: 796 case GL_INTENSITY16UI_EXT: 797 case GL_LUMINANCE16UI_EXT: 798 case GL_LUMINANCE_ALPHA16UI_EXT: 799 case GL_RGBA8UI_EXT: 800 case GL_RGB8UI_EXT: 801 case GL_ALPHA8UI_EXT: 802 case GL_INTENSITY8UI_EXT: 803 case GL_LUMINANCE8UI_EXT: 804 case GL_LUMINANCE_ALPHA8UI_EXT: 805 case GL_RGBA32I_EXT: 806 case GL_RGB32I_EXT: 807 case GL_ALPHA32I_EXT: 808 case GL_INTENSITY32I_EXT: 809 case GL_LUMINANCE32I_EXT: 810 case GL_LUMINANCE_ALPHA32I_EXT: 811 case GL_RGBA16I_EXT: 812 case GL_RGB16I_EXT: 813 case GL_ALPHA16I_EXT: 814 case GL_INTENSITY16I_EXT: 815 case GL_LUMINANCE16I_EXT: 816 case GL_LUMINANCE_ALPHA16I_EXT: 817 case GL_RGBA8I_EXT: 818 case GL_RGB8I_EXT: 819 case GL_ALPHA8I_EXT: 820 case GL_INTENSITY8I_EXT: 821 case GL_LUMINANCE8I_EXT: 822 case GL_LUMINANCE_ALPHA8I_EXT: 823 /* signed, normalized texture formats */ 824 case GL_RED_SNORM: 825 case GL_R8_SNORM: 826 case GL_R16_SNORM: 827 case GL_RG_SNORM: 828 case GL_RG8_SNORM: 829 case GL_RG16_SNORM: 830 case GL_RGB_SNORM: 831 case GL_RGB8_SNORM: 832 case GL_RGB16_SNORM: 833 case GL_RGBA_SNORM: 834 case GL_RGBA8_SNORM: 835 case GL_RGBA16_SNORM: 836 case GL_ALPHA_SNORM: 837 case GL_ALPHA8_SNORM: 838 case GL_ALPHA16_SNORM: 839 case GL_LUMINANCE_SNORM: 840 case GL_LUMINANCE8_SNORM: 841 case GL_LUMINANCE16_SNORM: 842 case GL_LUMINANCE_ALPHA_SNORM: 843 case GL_LUMINANCE8_ALPHA8_SNORM: 844 case GL_LUMINANCE16_ALPHA16_SNORM: 845 case GL_INTENSITY_SNORM: 846 case GL_INTENSITY8_SNORM: 847 case GL_INTENSITY16_SNORM: 848 case GL_RGB9_E5: 849 case GL_R11F_G11F_B10F: 850 return GL_TRUE; 851 case GL_YCBCR_MESA: /* not considered to be RGB */ 852 /* fall-through */ 853 default: 854 return GL_FALSE; 855 } 856} 857 858 859/** 860 * Test if the given image format is a depth component format. 861 */ 862GLboolean 863_mesa_is_depth_format(GLenum format) 864{ 865 switch (format) { 866 case GL_DEPTH_COMPONENT: 867 case GL_DEPTH_COMPONENT16: 868 case GL_DEPTH_COMPONENT24: 869 case GL_DEPTH_COMPONENT32: 870 case GL_DEPTH_COMPONENT32F: 871 return GL_TRUE; 872 default: 873 return GL_FALSE; 874 } 875} 876 877 878/** 879 * Test if the given image format is a stencil format. 880 */ 881GLboolean 882_mesa_is_stencil_format(GLenum format) 883{ 884 switch (format) { 885 case GL_STENCIL_INDEX: 886 case GL_DEPTH_STENCIL: 887 return GL_TRUE; 888 default: 889 return GL_FALSE; 890 } 891} 892 893 894/** 895 * Test if the given image format is a YCbCr format. 896 */ 897GLboolean 898_mesa_is_ycbcr_format(GLenum format) 899{ 900 switch (format) { 901 case GL_YCBCR_MESA: 902 return GL_TRUE; 903 default: 904 return GL_FALSE; 905 } 906} 907 908 909/** 910 * Test if the given image format is a depth+stencil format. 911 */ 912GLboolean 913_mesa_is_depthstencil_format(GLenum format) 914{ 915 switch (format) { 916 case GL_DEPTH24_STENCIL8_EXT: 917 case GL_DEPTH_STENCIL_EXT: 918 case GL_DEPTH32F_STENCIL8: 919 return GL_TRUE; 920 default: 921 return GL_FALSE; 922 } 923} 924 925 926/** 927 * Test if the given image format is a depth or stencil format. 928 */ 929GLboolean 930_mesa_is_depth_or_stencil_format(GLenum format) 931{ 932 switch (format) { 933 case GL_DEPTH_COMPONENT: 934 case GL_DEPTH_COMPONENT16: 935 case GL_DEPTH_COMPONENT24: 936 case GL_DEPTH_COMPONENT32: 937 case GL_STENCIL_INDEX: 938 case GL_STENCIL_INDEX1_EXT: 939 case GL_STENCIL_INDEX4_EXT: 940 case GL_STENCIL_INDEX8_EXT: 941 case GL_STENCIL_INDEX16_EXT: 942 case GL_DEPTH_STENCIL_EXT: 943 case GL_DEPTH24_STENCIL8_EXT: 944 case GL_DEPTH_COMPONENT32F: 945 case GL_DEPTH32F_STENCIL8: 946 return GL_TRUE; 947 default: 948 return GL_FALSE; 949 } 950} 951 952 953/** 954 * Test if the given image format is a dudv format. 955 */ 956GLboolean 957_mesa_is_dudv_format(GLenum format) 958{ 959 switch (format) { 960 case GL_DUDV_ATI: 961 case GL_DU8DV8_ATI: 962 return GL_TRUE; 963 default: 964 return GL_FALSE; 965 } 966} 967 968 969/** 970 * Test if the given format is an integer (non-normalized) format. 971 */ 972GLboolean 973_mesa_is_integer_format(GLenum format) 974{ 975 switch (format) { 976 /* generic integer formats */ 977 case GL_RED_INTEGER_EXT: 978 case GL_GREEN_INTEGER_EXT: 979 case GL_BLUE_INTEGER_EXT: 980 case GL_ALPHA_INTEGER_EXT: 981 case GL_RGB_INTEGER_EXT: 982 case GL_RGBA_INTEGER_EXT: 983 case GL_BGR_INTEGER_EXT: 984 case GL_BGRA_INTEGER_EXT: 985 case GL_LUMINANCE_INTEGER_EXT: 986 case GL_LUMINANCE_ALPHA_INTEGER_EXT: 987 /* specific integer formats */ 988 case GL_RGBA32UI_EXT: 989 case GL_RGB32UI_EXT: 990 case GL_ALPHA32UI_EXT: 991 case GL_INTENSITY32UI_EXT: 992 case GL_LUMINANCE32UI_EXT: 993 case GL_LUMINANCE_ALPHA32UI_EXT: 994 case GL_RGBA16UI_EXT: 995 case GL_RGB16UI_EXT: 996 case GL_ALPHA16UI_EXT: 997 case GL_INTENSITY16UI_EXT: 998 case GL_LUMINANCE16UI_EXT: 999 case GL_LUMINANCE_ALPHA16UI_EXT: 1000 case GL_RGBA8UI_EXT: 1001 case GL_RGB8UI_EXT: 1002 case GL_ALPHA8UI_EXT: 1003 case GL_INTENSITY8UI_EXT: 1004 case GL_LUMINANCE8UI_EXT: 1005 case GL_LUMINANCE_ALPHA8UI_EXT: 1006 case GL_RGBA32I_EXT: 1007 case GL_RGB32I_EXT: 1008 case GL_ALPHA32I_EXT: 1009 case GL_INTENSITY32I_EXT: 1010 case GL_LUMINANCE32I_EXT: 1011 case GL_LUMINANCE_ALPHA32I_EXT: 1012 case GL_RGBA16I_EXT: 1013 case GL_RGB16I_EXT: 1014 case GL_ALPHA16I_EXT: 1015 case GL_INTENSITY16I_EXT: 1016 case GL_LUMINANCE16I_EXT: 1017 case GL_LUMINANCE_ALPHA16I_EXT: 1018 case GL_RGBA8I_EXT: 1019 case GL_RGB8I_EXT: 1020 case GL_ALPHA8I_EXT: 1021 case GL_INTENSITY8I_EXT: 1022 case GL_LUMINANCE8I_EXT: 1023 case GL_LUMINANCE_ALPHA8I_EXT: 1024 return GL_TRUE; 1025 default: 1026 return GL_FALSE; 1027 } 1028} 1029 1030 1031/** 1032 * Test if an image format is a supported compressed format. 1033 * \param format the internal format token provided by the user. 1034 * \return GL_TRUE if compressed, GL_FALSE if uncompressed 1035 */ 1036GLboolean 1037_mesa_is_compressed_format(struct gl_context *ctx, GLenum format) 1038{ 1039 switch (format) { 1040 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: 1041 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: 1042 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: 1043 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: 1044 return ctx->Extensions.EXT_texture_compression_s3tc; 1045 case GL_RGB_S3TC: 1046 case GL_RGB4_S3TC: 1047 case GL_RGBA_S3TC: 1048 case GL_RGBA4_S3TC: 1049 return ctx->Extensions.S3_s3tc; 1050 case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: 1051 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 1052 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 1053 case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 1054 return ctx->Extensions.EXT_texture_sRGB 1055 && ctx->Extensions.EXT_texture_compression_s3tc; 1056 case GL_COMPRESSED_RGB_FXT1_3DFX: 1057 case GL_COMPRESSED_RGBA_FXT1_3DFX: 1058 return ctx->Extensions.TDFX_texture_compression_FXT1; 1059 case GL_COMPRESSED_RED_RGTC1: 1060 case GL_COMPRESSED_SIGNED_RED_RGTC1: 1061 case GL_COMPRESSED_RG_RGTC2: 1062 case GL_COMPRESSED_SIGNED_RG_RGTC2: 1063 return ctx->Extensions.ARB_texture_compression_rgtc; 1064 case GL_COMPRESSED_LUMINANCE_LATC1_EXT: 1065 case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT: 1066 case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT: 1067 case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT: 1068 return ctx->Extensions.EXT_texture_compression_latc; 1069 case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI: 1070 return ctx->Extensions.ATI_texture_compression_3dc; 1071 default: 1072 return GL_FALSE; 1073 } 1074} 1075 1076 1077/** 1078 * Return the address of a specific pixel in an image (1D, 2D or 3D). 1079 * 1080 * Pixel unpacking/packing parameters are observed according to \p packing. 1081 * 1082 * \param dimensions either 1, 2 or 3 to indicate dimensionality of image 1083 * \param image starting address of image data 1084 * \param width the image width 1085 * \param height theimage height 1086 * \param format the pixel format 1087 * \param type the pixel data type 1088 * \param packing the pixelstore attributes 1089 * \param img which image in the volume (0 for 1D or 2D images) 1090 * \param row row of pixel in the image (0 for 1D images) 1091 * \param column column of pixel in the image 1092 * 1093 * \return address of pixel on success, or NULL on error. 1094 * 1095 * \sa gl_pixelstore_attrib. 1096 */ 1097GLvoid * 1098_mesa_image_address( GLuint dimensions, 1099 const struct gl_pixelstore_attrib *packing, 1100 const GLvoid *image, 1101 GLsizei width, GLsizei height, 1102 GLenum format, GLenum type, 1103 GLint img, GLint row, GLint column ) 1104{ 1105 GLint alignment; /* 1, 2 or 4 */ 1106 GLint pixels_per_row; 1107 GLint rows_per_image; 1108 GLint skiprows; 1109 GLint skippixels; 1110 GLint skipimages; /* for 3-D volume images */ 1111 GLubyte *pixel_addr; 1112 1113 ASSERT(dimensions >= 1 && dimensions <= 3); 1114 1115 alignment = packing->Alignment; 1116 if (packing->RowLength > 0) { 1117 pixels_per_row = packing->RowLength; 1118 } 1119 else { 1120 pixels_per_row = width; 1121 } 1122 if (packing->ImageHeight > 0) { 1123 rows_per_image = packing->ImageHeight; 1124 } 1125 else { 1126 rows_per_image = height; 1127 } 1128 1129 skippixels = packing->SkipPixels; 1130 /* Note: SKIP_ROWS _is_ used for 1D images */ 1131 skiprows = packing->SkipRows; 1132 /* Note: SKIP_IMAGES is only used for 3D images */ 1133 skipimages = (dimensions == 3) ? packing->SkipImages : 0; 1134 1135 if (type == GL_BITMAP) { 1136 /* BITMAP data */ 1137 GLint comp_per_pixel; /* components per pixel */ 1138 GLint bytes_per_comp; /* bytes per component */ 1139 GLint bytes_per_row; 1140 GLint bytes_per_image; 1141 1142 /* Compute bytes per component */ 1143 bytes_per_comp = _mesa_sizeof_packed_type( type ); 1144 if (bytes_per_comp < 0) { 1145 return NULL; 1146 } 1147 1148 /* Compute number of components per pixel */ 1149 comp_per_pixel = _mesa_components_in_format( format ); 1150 if (comp_per_pixel < 0) { 1151 return NULL; 1152 } 1153 1154 bytes_per_row = alignment 1155 * CEILING( comp_per_pixel*pixels_per_row, 8*alignment ); 1156 1157 bytes_per_image = bytes_per_row * rows_per_image; 1158 1159 pixel_addr = (GLubyte *) image 1160 + (skipimages + img) * bytes_per_image 1161 + (skiprows + row) * bytes_per_row 1162 + (skippixels + column) / 8; 1163 } 1164 else { 1165 /* Non-BITMAP data */ 1166 GLint bytes_per_pixel, bytes_per_row, remainder, bytes_per_image; 1167 GLint topOfImage; 1168 1169 bytes_per_pixel = _mesa_bytes_per_pixel( format, type ); 1170 1171 /* The pixel type and format should have been error checked earlier */ 1172 assert(bytes_per_pixel > 0); 1173 1174 bytes_per_row = pixels_per_row * bytes_per_pixel; 1175 remainder = bytes_per_row % alignment; 1176 if (remainder > 0) 1177 bytes_per_row += (alignment - remainder); 1178 1179 ASSERT(bytes_per_row % alignment == 0); 1180 1181 bytes_per_image = bytes_per_row * rows_per_image; 1182 1183 if (packing->Invert) { 1184 /* set pixel_addr to the last row */ 1185 topOfImage = bytes_per_row * (height - 1); 1186 bytes_per_row = -bytes_per_row; 1187 } 1188 else { 1189 topOfImage = 0; 1190 } 1191 1192 /* compute final pixel address */ 1193 pixel_addr = (GLubyte *) image 1194 + (skipimages + img) * bytes_per_image 1195 + topOfImage 1196 + (skiprows + row) * bytes_per_row 1197 + (skippixels + column) * bytes_per_pixel; 1198 } 1199 1200 return (GLvoid *) pixel_addr; 1201} 1202 1203 1204GLvoid * 1205_mesa_image_address1d( const struct gl_pixelstore_attrib *packing, 1206 const GLvoid *image, 1207 GLsizei width, 1208 GLenum format, GLenum type, 1209 GLint column ) 1210{ 1211 return _mesa_image_address(1, packing, image, width, 1, 1212 format, type, 0, 0, column); 1213} 1214 1215 1216GLvoid * 1217_mesa_image_address2d( const struct gl_pixelstore_attrib *packing, 1218 const GLvoid *image, 1219 GLsizei width, GLsizei height, 1220 GLenum format, GLenum type, 1221 GLint row, GLint column ) 1222{ 1223 return _mesa_image_address(2, packing, image, width, height, 1224 format, type, 0, row, column); 1225} 1226 1227 1228GLvoid * 1229_mesa_image_address3d( const struct gl_pixelstore_attrib *packing, 1230 const GLvoid *image, 1231 GLsizei width, GLsizei height, 1232 GLenum format, GLenum type, 1233 GLint img, GLint row, GLint column ) 1234{ 1235 return _mesa_image_address(3, packing, image, width, height, 1236 format, type, img, row, column); 1237} 1238 1239 1240 1241/** 1242 * Compute the stride (in bytes) between image rows. 1243 * 1244 * \param packing the pixelstore attributes 1245 * \param width image width. 1246 * \param format pixel format. 1247 * \param type pixel data type. 1248 * 1249 * \return the stride in bytes for the given parameters, or -1 if error 1250 */ 1251GLint 1252_mesa_image_row_stride( const struct gl_pixelstore_attrib *packing, 1253 GLint width, GLenum format, GLenum type ) 1254{ 1255 GLint bytesPerRow, remainder; 1256 1257 ASSERT(packing); 1258 1259 if (type == GL_BITMAP) { 1260 if (packing->RowLength == 0) { 1261 bytesPerRow = (width + 7) / 8; 1262 } 1263 else { 1264 bytesPerRow = (packing->RowLength + 7) / 8; 1265 } 1266 } 1267 else { 1268 /* Non-BITMAP data */ 1269 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 1270 if (bytesPerPixel <= 0) 1271 return -1; /* error */ 1272 if (packing->RowLength == 0) { 1273 bytesPerRow = bytesPerPixel * width; 1274 } 1275 else { 1276 bytesPerRow = bytesPerPixel * packing->RowLength; 1277 } 1278 } 1279 1280 remainder = bytesPerRow % packing->Alignment; 1281 if (remainder > 0) { 1282 bytesPerRow += (packing->Alignment - remainder); 1283 } 1284 1285 if (packing->Invert) { 1286 /* negate the bytes per row (negative row stride) */ 1287 bytesPerRow = -bytesPerRow; 1288 } 1289 1290 return bytesPerRow; 1291} 1292 1293 1294/* 1295 * Compute the stride between images in a 3D texture (in bytes) for the given 1296 * pixel packing parameters and image width, format and type. 1297 */ 1298GLint 1299_mesa_image_image_stride( const struct gl_pixelstore_attrib *packing, 1300 GLint width, GLint height, 1301 GLenum format, GLenum type ) 1302{ 1303 GLint bytesPerRow, bytesPerImage, remainder; 1304 1305 ASSERT(packing); 1306 1307 if (type == GL_BITMAP) { 1308 if (packing->RowLength == 0) { 1309 bytesPerRow = (width + 7) / 8; 1310 } 1311 else { 1312 bytesPerRow = (packing->RowLength + 7) / 8; 1313 } 1314 } 1315 else { 1316 const GLint bytesPerPixel = _mesa_bytes_per_pixel(format, type); 1317 1318 if (bytesPerPixel <= 0) 1319 return -1; /* error */ 1320 if (packing->RowLength == 0) { 1321 bytesPerRow = bytesPerPixel * width; 1322 } 1323 else { 1324 bytesPerRow = bytesPerPixel * packing->RowLength; 1325 } 1326 } 1327 1328 remainder = bytesPerRow % packing->Alignment; 1329 if (remainder > 0) 1330 bytesPerRow += (packing->Alignment - remainder); 1331 1332 if (packing->ImageHeight == 0) 1333 bytesPerImage = bytesPerRow * height; 1334 else 1335 bytesPerImage = bytesPerRow * packing->ImageHeight; 1336 1337 return bytesPerImage; 1338} 1339 1340 1341 1342/** 1343 * "Expand" a bitmap from 1-bit per pixel to 8-bits per pixel. 1344 * This is typically used to convert a bitmap into a GLubyte/pixel texture. 1345 * "On" bits will set texels to \p onValue. 1346 * "Off" bits will not modify texels. 1347 * \param width src bitmap width in pixels 1348 * \param height src bitmap height in pixels 1349 * \param unpack bitmap unpacking state 1350 * \param bitmap the src bitmap data 1351 * \param destBuffer start of dest buffer 1352 * \param destStride row stride in dest buffer 1353 * \param onValue if bit is 1, set destBuffer pixel to this value 1354 */ 1355void 1356_mesa_expand_bitmap(GLsizei width, GLsizei height, 1357 const struct gl_pixelstore_attrib *unpack, 1358 const GLubyte *bitmap, 1359 GLubyte *destBuffer, GLint destStride, 1360 GLubyte onValue) 1361{ 1362 const GLubyte *srcRow = (const GLubyte *) 1363 _mesa_image_address2d(unpack, bitmap, width, height, 1364 GL_COLOR_INDEX, GL_BITMAP, 0, 0); 1365 const GLint srcStride = _mesa_image_row_stride(unpack, width, 1366 GL_COLOR_INDEX, GL_BITMAP); 1367 GLint row, col; 1368 1369#define SET_PIXEL(COL, ROW) \ 1370 destBuffer[(ROW) * destStride + (COL)] = onValue; 1371 1372 for (row = 0; row < height; row++) { 1373 const GLubyte *src = srcRow; 1374 1375 if (unpack->LsbFirst) { 1376 /* Lsb first */ 1377 GLubyte mask = 1U << (unpack->SkipPixels & 0x7); 1378 for (col = 0; col < width; col++) { 1379 1380 if (*src & mask) { 1381 SET_PIXEL(col, row); 1382 } 1383 1384 if (mask == 128U) { 1385 src++; 1386 mask = 1U; 1387 } 1388 else { 1389 mask = mask << 1; 1390 } 1391 } 1392 1393 /* get ready for next row */ 1394 if (mask != 1) 1395 src++; 1396 } 1397 else { 1398 /* Msb first */ 1399 GLubyte mask = 128U >> (unpack->SkipPixels & 0x7); 1400 for (col = 0; col < width; col++) { 1401 1402 if (*src & mask) { 1403 SET_PIXEL(col, row); 1404 } 1405 1406 if (mask == 1U) { 1407 src++; 1408 mask = 128U; 1409 } 1410 else { 1411 mask = mask >> 1; 1412 } 1413 } 1414 1415 /* get ready for next row */ 1416 if (mask != 128) 1417 src++; 1418 } 1419 1420 srcRow += srcStride; 1421 } /* row */ 1422 1423#undef SET_PIXEL 1424} 1425 1426 1427 1428 1429/** 1430 * Convert an array of RGBA colors from one datatype to another. 1431 * NOTE: src may equal dst. In that case, we use a temporary buffer. 1432 */ 1433void 1434_mesa_convert_colors(GLenum srcType, const GLvoid *src, 1435 GLenum dstType, GLvoid *dst, 1436 GLuint count, const GLubyte mask[]) 1437{ 1438 GLuint tempBuffer[MAX_WIDTH][4]; 1439 const GLboolean useTemp = (src == dst); 1440 1441 ASSERT(srcType != dstType); 1442 1443 switch (srcType) { 1444 case GL_UNSIGNED_BYTE: 1445 if (dstType == GL_UNSIGNED_SHORT) { 1446 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 1447 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 1448 GLuint i; 1449 for (i = 0; i < count; i++) { 1450 if (!mask || mask[i]) { 1451 dst2[i][RCOMP] = UBYTE_TO_USHORT(src1[i][RCOMP]); 1452 dst2[i][GCOMP] = UBYTE_TO_USHORT(src1[i][GCOMP]); 1453 dst2[i][BCOMP] = UBYTE_TO_USHORT(src1[i][BCOMP]); 1454 dst2[i][ACOMP] = UBYTE_TO_USHORT(src1[i][ACOMP]); 1455 } 1456 } 1457 if (useTemp) 1458 memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 1459 } 1460 else { 1461 const GLubyte (*src1)[4] = (const GLubyte (*)[4]) src; 1462 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 1463 GLuint i; 1464 ASSERT(dstType == GL_FLOAT); 1465 for (i = 0; i < count; i++) { 1466 if (!mask || mask[i]) { 1467 dst4[i][RCOMP] = UBYTE_TO_FLOAT(src1[i][RCOMP]); 1468 dst4[i][GCOMP] = UBYTE_TO_FLOAT(src1[i][GCOMP]); 1469 dst4[i][BCOMP] = UBYTE_TO_FLOAT(src1[i][BCOMP]); 1470 dst4[i][ACOMP] = UBYTE_TO_FLOAT(src1[i][ACOMP]); 1471 } 1472 } 1473 if (useTemp) 1474 memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 1475 } 1476 break; 1477 case GL_UNSIGNED_SHORT: 1478 if (dstType == GL_UNSIGNED_BYTE) { 1479 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 1480 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 1481 GLuint i; 1482 for (i = 0; i < count; i++) { 1483 if (!mask || mask[i]) { 1484 dst1[i][RCOMP] = USHORT_TO_UBYTE(src2[i][RCOMP]); 1485 dst1[i][GCOMP] = USHORT_TO_UBYTE(src2[i][GCOMP]); 1486 dst1[i][BCOMP] = USHORT_TO_UBYTE(src2[i][BCOMP]); 1487 dst1[i][ACOMP] = USHORT_TO_UBYTE(src2[i][ACOMP]); 1488 } 1489 } 1490 if (useTemp) 1491 memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 1492 } 1493 else { 1494 const GLushort (*src2)[4] = (const GLushort (*)[4]) src; 1495 GLfloat (*dst4)[4] = (GLfloat (*)[4]) (useTemp ? tempBuffer : dst); 1496 GLuint i; 1497 ASSERT(dstType == GL_FLOAT); 1498 for (i = 0; i < count; i++) { 1499 if (!mask || mask[i]) { 1500 dst4[i][RCOMP] = USHORT_TO_FLOAT(src2[i][RCOMP]); 1501 dst4[i][GCOMP] = USHORT_TO_FLOAT(src2[i][GCOMP]); 1502 dst4[i][BCOMP] = USHORT_TO_FLOAT(src2[i][BCOMP]); 1503 dst4[i][ACOMP] = USHORT_TO_FLOAT(src2[i][ACOMP]); 1504 } 1505 } 1506 if (useTemp) 1507 memcpy(dst, tempBuffer, count * 4 * sizeof(GLfloat)); 1508 } 1509 break; 1510 case GL_FLOAT: 1511 if (dstType == GL_UNSIGNED_BYTE) { 1512 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 1513 GLubyte (*dst1)[4] = (GLubyte (*)[4]) (useTemp ? tempBuffer : dst); 1514 GLuint i; 1515 for (i = 0; i < count; i++) { 1516 if (!mask || mask[i]) { 1517 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][RCOMP], src4[i][RCOMP]); 1518 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][GCOMP], src4[i][GCOMP]); 1519 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][BCOMP], src4[i][BCOMP]); 1520 UNCLAMPED_FLOAT_TO_UBYTE(dst1[i][ACOMP], src4[i][ACOMP]); 1521 } 1522 } 1523 if (useTemp) 1524 memcpy(dst, tempBuffer, count * 4 * sizeof(GLubyte)); 1525 } 1526 else { 1527 const GLfloat (*src4)[4] = (const GLfloat (*)[4]) src; 1528 GLushort (*dst2)[4] = (GLushort (*)[4]) (useTemp ? tempBuffer : dst); 1529 GLuint i; 1530 ASSERT(dstType == GL_UNSIGNED_SHORT); 1531 for (i = 0; i < count; i++) { 1532 if (!mask || mask[i]) { 1533 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][RCOMP], src4[i][RCOMP]); 1534 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][GCOMP], src4[i][GCOMP]); 1535 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][BCOMP], src4[i][BCOMP]); 1536 UNCLAMPED_FLOAT_TO_USHORT(dst2[i][ACOMP], src4[i][ACOMP]); 1537 } 1538 } 1539 if (useTemp) 1540 memcpy(dst, tempBuffer, count * 4 * sizeof(GLushort)); 1541 } 1542 break; 1543 default: 1544 _mesa_problem(NULL, "Invalid datatype in _mesa_convert_colors"); 1545 } 1546} 1547 1548 1549 1550 1551/** 1552 * Perform basic clipping for glDrawPixels. The image's position and size 1553 * and the unpack SkipPixels and SkipRows are adjusted so that the image 1554 * region is entirely within the window and scissor bounds. 1555 * NOTE: this will only work when glPixelZoom is (1, 1) or (1, -1). 1556 * If Pixel.ZoomY is -1, *destY will be changed to be the first row which 1557 * we'll actually write. Beforehand, *destY-1 is the first drawing row. 1558 * 1559 * \return GL_TRUE if image is ready for drawing or 1560 * GL_FALSE if image was completely clipped away (draw nothing) 1561 */ 1562GLboolean 1563_mesa_clip_drawpixels(const struct gl_context *ctx, 1564 GLint *destX, GLint *destY, 1565 GLsizei *width, GLsizei *height, 1566 struct gl_pixelstore_attrib *unpack) 1567{ 1568 const struct gl_framebuffer *buffer = ctx->DrawBuffer; 1569 1570 if (unpack->RowLength == 0) { 1571 unpack->RowLength = *width; 1572 } 1573 1574 ASSERT(ctx->Pixel.ZoomX == 1.0F); 1575 ASSERT(ctx->Pixel.ZoomY == 1.0F || ctx->Pixel.ZoomY == -1.0F); 1576 1577 /* left clipping */ 1578 if (*destX < buffer->_Xmin) { 1579 unpack->SkipPixels += (buffer->_Xmin - *destX); 1580 *width -= (buffer->_Xmin - *destX); 1581 *destX = buffer->_Xmin; 1582 } 1583 /* right clipping */ 1584 if (*destX + *width > buffer->_Xmax) 1585 *width -= (*destX + *width - buffer->_Xmax); 1586 1587 if (*width <= 0) 1588 return GL_FALSE; 1589 1590 if (ctx->Pixel.ZoomY == 1.0F) { 1591 /* bottom clipping */ 1592 if (*destY < buffer->_Ymin) { 1593 unpack->SkipRows += (buffer->_Ymin - *destY); 1594 *height -= (buffer->_Ymin - *destY); 1595 *destY = buffer->_Ymin; 1596 } 1597 /* top clipping */ 1598 if (*destY + *height > buffer->_Ymax) 1599 *height -= (*destY + *height - buffer->_Ymax); 1600 } 1601 else { /* upside down */ 1602 /* top clipping */ 1603 if (*destY > buffer->_Ymax) { 1604 unpack->SkipRows += (*destY - buffer->_Ymax); 1605 *height -= (*destY - buffer->_Ymax); 1606 *destY = buffer->_Ymax; 1607 } 1608 /* bottom clipping */ 1609 if (*destY - *height < buffer->_Ymin) 1610 *height -= (buffer->_Ymin - (*destY - *height)); 1611 /* adjust destY so it's the first row to write to */ 1612 (*destY)--; 1613 } 1614 1615 if (*height <= 0) 1616 return GL_FALSE; 1617 1618 return GL_TRUE; 1619} 1620 1621 1622/** 1623 * Perform clipping for glReadPixels. The image's window position 1624 * and size, and the pack skipPixels, skipRows and rowLength are adjusted 1625 * so that the image region is entirely within the window bounds. 1626 * Note: this is different from _mesa_clip_drawpixels() in that the 1627 * scissor box is ignored, and we use the bounds of the current readbuffer 1628 * surface. 1629 * 1630 * \return GL_TRUE if region to read is in bounds 1631 * GL_FALSE if region is completely out of bounds (nothing to read) 1632 */ 1633GLboolean 1634_mesa_clip_readpixels(const struct gl_context *ctx, 1635 GLint *srcX, GLint *srcY, 1636 GLsizei *width, GLsizei *height, 1637 struct gl_pixelstore_attrib *pack) 1638{ 1639 const struct gl_framebuffer *buffer = ctx->ReadBuffer; 1640 1641 if (pack->RowLength == 0) { 1642 pack->RowLength = *width; 1643 } 1644 1645 /* left clipping */ 1646 if (*srcX < 0) { 1647 pack->SkipPixels += (0 - *srcX); 1648 *width -= (0 - *srcX); 1649 *srcX = 0; 1650 } 1651 /* right clipping */ 1652 if (*srcX + *width > (GLsizei) buffer->Width) 1653 *width -= (*srcX + *width - buffer->Width); 1654 1655 if (*width <= 0) 1656 return GL_FALSE; 1657 1658 /* bottom clipping */ 1659 if (*srcY < 0) { 1660 pack->SkipRows += (0 - *srcY); 1661 *height -= (0 - *srcY); 1662 *srcY = 0; 1663 } 1664 /* top clipping */ 1665 if (*srcY + *height > (GLsizei) buffer->Height) 1666 *height -= (*srcY + *height - buffer->Height); 1667 1668 if (*height <= 0) 1669 return GL_FALSE; 1670 1671 return GL_TRUE; 1672} 1673 1674 1675/** 1676 * Do clipping for a glCopyTexSubImage call. 1677 * The framebuffer source region might extend outside the framebuffer 1678 * bounds. Clip the source region against the framebuffer bounds and 1679 * adjust the texture/dest position and size accordingly. 1680 * 1681 * \return GL_FALSE if region is totally clipped, GL_TRUE otherwise. 1682 */ 1683GLboolean 1684_mesa_clip_copytexsubimage(const struct gl_context *ctx, 1685 GLint *destX, GLint *destY, 1686 GLint *srcX, GLint *srcY, 1687 GLsizei *width, GLsizei *height) 1688{ 1689 const struct gl_framebuffer *fb = ctx->ReadBuffer; 1690 const GLint srcX0 = *srcX, srcY0 = *srcY; 1691 1692 if (_mesa_clip_to_region(0, 0, fb->Width, fb->Height, 1693 srcX, srcY, width, height)) { 1694 *destX = *destX + *srcX - srcX0; 1695 *destY = *destY + *srcY - srcY0; 1696 1697 return GL_TRUE; 1698 } 1699 else { 1700 return GL_FALSE; 1701 } 1702} 1703 1704 1705 1706/** 1707 * Clip the rectangle defined by (x, y, width, height) against the bounds 1708 * specified by [xmin, xmax) and [ymin, ymax). 1709 * \return GL_FALSE if rect is totally clipped, GL_TRUE otherwise. 1710 */ 1711GLboolean 1712_mesa_clip_to_region(GLint xmin, GLint ymin, 1713 GLint xmax, GLint ymax, 1714 GLint *x, GLint *y, 1715 GLsizei *width, GLsizei *height ) 1716{ 1717 /* left clipping */ 1718 if (*x < xmin) { 1719 *width -= (xmin - *x); 1720 *x = xmin; 1721 } 1722 1723 /* right clipping */ 1724 if (*x + *width > xmax) 1725 *width -= (*x + *width - xmax); 1726 1727 if (*width <= 0) 1728 return GL_FALSE; 1729 1730 /* bottom (or top) clipping */ 1731 if (*y < ymin) { 1732 *height -= (ymin - *y); 1733 *y = ymin; 1734 } 1735 1736 /* top (or bottom) clipping */ 1737 if (*y + *height > ymax) 1738 *height -= (*y + *height - ymax); 1739 1740 if (*height <= 0) 1741 return GL_FALSE; 1742 1743 return GL_TRUE; 1744} 1745 1746 1747/** 1748 * Clip dst coords against Xmax (or Ymax). 1749 */ 1750static INLINE void 1751clip_right_or_top(GLint *srcX0, GLint *srcX1, 1752 GLint *dstX0, GLint *dstX1, 1753 GLint maxValue) 1754{ 1755 GLfloat t, bias; 1756 1757 if (*dstX1 > maxValue) { 1758 /* X1 outside right edge */ 1759 ASSERT(*dstX0 < maxValue); /* X0 should be inside right edge */ 1760 t = (GLfloat) (maxValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0); 1761 /* chop off [t, 1] part */ 1762 ASSERT(t >= 0.0 && t <= 1.0); 1763 *dstX1 = maxValue; 1764 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; 1765 *srcX1 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias); 1766 } 1767 else if (*dstX0 > maxValue) { 1768 /* X0 outside right edge */ 1769 ASSERT(*dstX1 < maxValue); /* X1 should be inside right edge */ 1770 t = (GLfloat) (maxValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1); 1771 /* chop off [t, 1] part */ 1772 ASSERT(t >= 0.0 && t <= 1.0); 1773 *dstX0 = maxValue; 1774 bias = (*srcX0 < *srcX1) ? -0.5F : 0.5F; 1775 *srcX0 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias); 1776 } 1777} 1778 1779 1780/** 1781 * Clip dst coords against Xmin (or Ymin). 1782 */ 1783static INLINE void 1784clip_left_or_bottom(GLint *srcX0, GLint *srcX1, 1785 GLint *dstX0, GLint *dstX1, 1786 GLint minValue) 1787{ 1788 GLfloat t, bias; 1789 1790 if (*dstX0 < minValue) { 1791 /* X0 outside left edge */ 1792 ASSERT(*dstX1 > minValue); /* X1 should be inside left edge */ 1793 t = (GLfloat) (minValue - *dstX0) / (GLfloat) (*dstX1 - *dstX0); 1794 /* chop off [0, t] part */ 1795 ASSERT(t >= 0.0 && t <= 1.0); 1796 *dstX0 = minValue; 1797 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; /* flipped??? */ 1798 *srcX0 = *srcX0 + (GLint) (t * (*srcX1 - *srcX0) + bias); 1799 } 1800 else if (*dstX1 < minValue) { 1801 /* X1 outside left edge */ 1802 ASSERT(*dstX0 > minValue); /* X0 should be inside left edge */ 1803 t = (GLfloat) (minValue - *dstX1) / (GLfloat) (*dstX0 - *dstX1); 1804 /* chop off [0, t] part */ 1805 ASSERT(t >= 0.0 && t <= 1.0); 1806 *dstX1 = minValue; 1807 bias = (*srcX0 < *srcX1) ? 0.5F : -0.5F; 1808 *srcX1 = *srcX1 + (GLint) (t * (*srcX0 - *srcX1) + bias); 1809 } 1810} 1811 1812 1813/** 1814 * Do clipping of blit src/dest rectangles. 1815 * The dest rect is clipped against both the buffer bounds and scissor bounds. 1816 * The src rect is just clipped against the buffer bounds. 1817 * 1818 * When either the src or dest rect is clipped, the other is also clipped 1819 * proportionately! 1820 * 1821 * Note that X0 need not be less than X1 (same for Y) for either the source 1822 * and dest rects. That makes the clipping a little trickier. 1823 * 1824 * \return GL_TRUE if anything is left to draw, GL_FALSE if totally clipped 1825 */ 1826GLboolean 1827_mesa_clip_blit(struct gl_context *ctx, 1828 GLint *srcX0, GLint *srcY0, GLint *srcX1, GLint *srcY1, 1829 GLint *dstX0, GLint *dstY0, GLint *dstX1, GLint *dstY1) 1830{ 1831 const GLint srcXmin = 0; 1832 const GLint srcXmax = ctx->ReadBuffer->Width; 1833 const GLint srcYmin = 0; 1834 const GLint srcYmax = ctx->ReadBuffer->Height; 1835 1836 /* these include scissor bounds */ 1837 const GLint dstXmin = ctx->DrawBuffer->_Xmin; 1838 const GLint dstXmax = ctx->DrawBuffer->_Xmax; 1839 const GLint dstYmin = ctx->DrawBuffer->_Ymin; 1840 const GLint dstYmax = ctx->DrawBuffer->_Ymax; 1841 1842 /* 1843 printf("PreClipX: src: %d .. %d dst: %d .. %d\n", 1844 *srcX0, *srcX1, *dstX0, *dstX1); 1845 printf("PreClipY: src: %d .. %d dst: %d .. %d\n", 1846 *srcY0, *srcY1, *dstY0, *dstY1); 1847 */ 1848 1849 /* trivial rejection tests */ 1850 if (*dstX0 == *dstX1) 1851 return GL_FALSE; /* no width */ 1852 if (*dstX0 <= dstXmin && *dstX1 <= dstXmin) 1853 return GL_FALSE; /* totally out (left) of bounds */ 1854 if (*dstX0 >= dstXmax && *dstX1 >= dstXmax) 1855 return GL_FALSE; /* totally out (right) of bounds */ 1856 1857 if (*dstY0 == *dstY1) 1858 return GL_FALSE; 1859 if (*dstY0 <= dstYmin && *dstY1 <= dstYmin) 1860 return GL_FALSE; 1861 if (*dstY0 >= dstYmax && *dstY1 >= dstYmax) 1862 return GL_FALSE; 1863 1864 if (*srcX0 == *srcX1) 1865 return GL_FALSE; 1866 if (*srcX0 <= srcXmin && *srcX1 <= srcXmin) 1867 return GL_FALSE; 1868 if (*srcX0 >= srcXmax && *srcX1 >= srcXmax) 1869 return GL_FALSE; 1870 1871 if (*srcY0 == *srcY1) 1872 return GL_FALSE; 1873 if (*srcY0 <= srcYmin && *srcY1 <= srcYmin) 1874 return GL_FALSE; 1875 if (*srcY0 >= srcYmax && *srcY1 >= srcYmax) 1876 return GL_FALSE; 1877 1878 /* 1879 * dest clip 1880 */ 1881 clip_right_or_top(srcX0, srcX1, dstX0, dstX1, dstXmax); 1882 clip_right_or_top(srcY0, srcY1, dstY0, dstY1, dstYmax); 1883 clip_left_or_bottom(srcX0, srcX1, dstX0, dstX1, dstXmin); 1884 clip_left_or_bottom(srcY0, srcY1, dstY0, dstY1, dstYmin); 1885 1886 /* 1887 * src clip (just swap src/dst values from above) 1888 */ 1889 clip_right_or_top(dstX0, dstX1, srcX0, srcX1, srcXmax); 1890 clip_right_or_top(dstY0, dstY1, srcY0, srcY1, srcYmax); 1891 clip_left_or_bottom(dstX0, dstX1, srcX0, srcX1, srcXmin); 1892 clip_left_or_bottom(dstY0, dstY1, srcY0, srcY1, srcYmin); 1893 1894 /* 1895 printf("PostClipX: src: %d .. %d dst: %d .. %d\n", 1896 *srcX0, *srcX1, *dstX0, *dstX1); 1897 printf("PostClipY: src: %d .. %d dst: %d .. %d\n", 1898 *srcY0, *srcY1, *dstY0, *dstY1); 1899 */ 1900 1901 ASSERT(*dstX0 >= dstXmin); 1902 ASSERT(*dstX0 <= dstXmax); 1903 ASSERT(*dstX1 >= dstXmin); 1904 ASSERT(*dstX1 <= dstXmax); 1905 1906 ASSERT(*dstY0 >= dstYmin); 1907 ASSERT(*dstY0 <= dstYmax); 1908 ASSERT(*dstY1 >= dstYmin); 1909 ASSERT(*dstY1 <= dstYmax); 1910 1911 ASSERT(*srcX0 >= srcXmin); 1912 ASSERT(*srcX0 <= srcXmax); 1913 ASSERT(*srcX1 >= srcXmin); 1914 ASSERT(*srcX1 <= srcXmax); 1915 1916 ASSERT(*srcY0 >= srcYmin); 1917 ASSERT(*srcY0 <= srcYmax); 1918 ASSERT(*srcY1 >= srcYmin); 1919 ASSERT(*srcY1 <= srcYmax); 1920 1921 return GL_TRUE; 1922} 1923