1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. 5 * Copyright (C) 2009 VMware, Inc. 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 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 #include <stdio.h> 27 #include "mtypes.h" 28 #include "attrib.h" 29 #include "enums.h" 30 #include "formats.h" 31 #include "hash.h" 32 #include "imports.h" 33 #include "macros.h" 34 #include "debug.h" 35 #include "get.h" 36 #include "pixelstore.h" 37 #include "readpix.h" 38 #include "texobj.h" 39 40 41 static const char * 42 tex_target_name(GLenum tgt) 43 { 44 static const struct { 45 GLenum target; 46 const char *name; 47 } tex_targets[] = { 48 { GL_TEXTURE_1D, "GL_TEXTURE_1D" }, 49 { GL_TEXTURE_2D, "GL_TEXTURE_2D" }, 50 { GL_TEXTURE_3D, "GL_TEXTURE_3D" }, 51 { GL_TEXTURE_CUBE_MAP, "GL_TEXTURE_CUBE_MAP" }, 52 { GL_TEXTURE_RECTANGLE, "GL_TEXTURE_RECTANGLE" }, 53 { GL_TEXTURE_1D_ARRAY_EXT, "GL_TEXTURE_1D_ARRAY" }, 54 { GL_TEXTURE_2D_ARRAY_EXT, "GL_TEXTURE_2D_ARRAY" }, 55 { GL_TEXTURE_CUBE_MAP_ARRAY, "GL_TEXTURE_CUBE_MAP_ARRAY" }, 56 { GL_TEXTURE_BUFFER, "GL_TEXTURE_BUFFER" }, 57 { GL_TEXTURE_2D_MULTISAMPLE, "GL_TEXTURE_2D_MULTISAMPLE" }, 58 { GL_TEXTURE_2D_MULTISAMPLE_ARRAY, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY" }, 59 { GL_TEXTURE_EXTERNAL_OES, "GL_TEXTURE_EXTERNAL_OES" } 60 }; 61 GLuint i; 62 STATIC_ASSERT(ARRAY_SIZE(tex_targets) == NUM_TEXTURE_TARGETS); 63 for (i = 0; i < ARRAY_SIZE(tex_targets); i++) { 64 if (tex_targets[i].target == tgt) 65 return tex_targets[i].name; 66 } 67 return "UNKNOWN TEX TARGET"; 68 } 69 70 71 void 72 _mesa_print_state( const char *msg, GLuint state ) 73 { 74 _mesa_debug(NULL, 75 "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", 76 msg, 77 state, 78 (state & _NEW_MODELVIEW) ? "ctx->ModelView, " : "", 79 (state & _NEW_PROJECTION) ? "ctx->Projection, " : "", 80 (state & _NEW_TEXTURE_MATRIX) ? "ctx->TextureMatrix, " : "", 81 (state & _NEW_COLOR) ? "ctx->Color, " : "", 82 (state & _NEW_DEPTH) ? "ctx->Depth, " : "", 83 (state & _NEW_EVAL) ? "ctx->Eval/EvalMap, " : "", 84 (state & _NEW_FOG) ? "ctx->Fog, " : "", 85 (state & _NEW_HINT) ? "ctx->Hint, " : "", 86 (state & _NEW_LIGHT) ? "ctx->Light, " : "", 87 (state & _NEW_LINE) ? "ctx->Line, " : "", 88 (state & _NEW_PIXEL) ? "ctx->Pixel, " : "", 89 (state & _NEW_POINT) ? "ctx->Point, " : "", 90 (state & _NEW_POLYGON) ? "ctx->Polygon, " : "", 91 (state & _NEW_POLYGONSTIPPLE) ? "ctx->PolygonStipple, " : "", 92 (state & _NEW_SCISSOR) ? "ctx->Scissor, " : "", 93 (state & _NEW_STENCIL) ? "ctx->Stencil, " : "", 94 (state & _NEW_TEXTURE) ? "ctx->Texture, " : "", 95 (state & _NEW_TRANSFORM) ? "ctx->Transform, " : "", 96 (state & _NEW_VIEWPORT) ? "ctx->Viewport, " : "", 97 (state & _NEW_ARRAY) ? "ctx->Array, " : "", 98 (state & _NEW_RENDERMODE) ? "ctx->RenderMode, " : "", 99 (state & _NEW_BUFFERS) ? "ctx->Visual, ctx->DrawBuffer,, " : ""); 100 } 101 102 103 104 /** 105 * Print information about this Mesa version and build options. 106 */ 107 void _mesa_print_info( struct gl_context *ctx ) 108 { 109 _mesa_debug(NULL, "Mesa GL_VERSION = %s\n", 110 (char *) _mesa_GetString(GL_VERSION)); 111 _mesa_debug(NULL, "Mesa GL_RENDERER = %s\n", 112 (char *) _mesa_GetString(GL_RENDERER)); 113 _mesa_debug(NULL, "Mesa GL_VENDOR = %s\n", 114 (char *) _mesa_GetString(GL_VENDOR)); 115 116 /* use ctx as GL_EXTENSIONS will not work on 3.0 or higher 117 * core contexts. 118 */ 119 _mesa_debug(NULL, "Mesa GL_EXTENSIONS = %s\n", ctx->Extensions.String); 120 121 #if defined(USE_X86_ASM) 122 _mesa_debug(NULL, "Mesa x86-optimized: YES\n"); 123 #else 124 _mesa_debug(NULL, "Mesa x86-optimized: NO\n"); 125 #endif 126 #if defined(USE_SPARC_ASM) 127 _mesa_debug(NULL, "Mesa sparc-optimized: YES\n"); 128 #else 129 _mesa_debug(NULL, "Mesa sparc-optimized: NO\n"); 130 #endif 131 } 132 133 134 /** 135 * Set verbose logging flags. When these flags are set, GL API calls 136 * in the various categories will be printed to stderr. 137 * \param str a comma-separated list of keywords 138 */ 139 static void 140 set_verbose_flags(const char *str) 141 { 142 #ifdef DEBUG 143 struct option { 144 const char *name; 145 GLbitfield flag; 146 }; 147 static const struct option opts[] = { 148 { "varray", VERBOSE_VARRAY }, 149 { "tex", VERBOSE_TEXTURE }, 150 { "mat", VERBOSE_MATERIAL }, 151 { "pipe", VERBOSE_PIPELINE }, 152 { "driver", VERBOSE_DRIVER }, 153 { "state", VERBOSE_STATE }, 154 { "api", VERBOSE_API }, 155 { "list", VERBOSE_DISPLAY_LIST }, 156 { "lighting", VERBOSE_LIGHTING }, 157 { "disassem", VERBOSE_DISASSEM }, 158 { "draw", VERBOSE_DRAW }, 159 { "swap", VERBOSE_SWAPBUFFERS } 160 }; 161 GLuint i; 162 163 if (!str) 164 return; 165 166 MESA_VERBOSE = 0x0; 167 for (i = 0; i < ARRAY_SIZE(opts); i++) { 168 if (strstr(str, opts[i].name) || strcmp(str, "all") == 0) 169 MESA_VERBOSE |= opts[i].flag; 170 } 171 #endif 172 } 173 174 175 /** 176 * Set debugging flags. When these flags are set, Mesa will do additional 177 * debug checks or actions. 178 * \param str a comma-separated list of keywords 179 */ 180 static void 181 set_debug_flags(const char *str) 182 { 183 #ifdef DEBUG 184 struct option { 185 const char *name; 186 GLbitfield flag; 187 }; 188 static const struct option opts[] = { 189 { "silent", DEBUG_SILENT }, /* turn off debug messages */ 190 { "flush", DEBUG_ALWAYS_FLUSH }, /* flush after each drawing command */ 191 { "incomplete_tex", DEBUG_INCOMPLETE_TEXTURE }, 192 { "incomplete_fbo", DEBUG_INCOMPLETE_FBO }, 193 { "context", DEBUG_CONTEXT } /* force set GL_CONTEXT_FLAG_DEBUG_BIT flag */ 194 }; 195 GLuint i; 196 197 if (!str) 198 return; 199 200 MESA_DEBUG_FLAGS = 0x0; 201 for (i = 0; i < ARRAY_SIZE(opts); i++) { 202 if (strstr(str, opts[i].name)) 203 MESA_DEBUG_FLAGS |= opts[i].flag; 204 } 205 #endif 206 } 207 208 209 /** 210 * Initialize debugging variables from env vars. 211 */ 212 void 213 _mesa_init_debug( struct gl_context *ctx ) 214 { 215 set_debug_flags(getenv("MESA_DEBUG")); 216 set_verbose_flags(getenv("MESA_VERBOSE")); 217 } 218 219 220 /* 221 * Write ppm file 222 */ 223 static void 224 write_ppm(const char *filename, const GLubyte *buffer, int width, int height, 225 int comps, int rcomp, int gcomp, int bcomp, GLboolean invert) 226 { 227 FILE *f = fopen( filename, "w" ); 228 if (f) { 229 int x, y; 230 const GLubyte *ptr = buffer; 231 fprintf(f,"P6\n"); 232 fprintf(f,"# ppm-file created by osdemo.c\n"); 233 fprintf(f,"%i %i\n", width,height); 234 fprintf(f,"255\n"); 235 fclose(f); 236 f = fopen( filename, "ab" ); /* reopen in binary append mode */ 237 for (y=0; y < height; y++) { 238 for (x = 0; x < width; x++) { 239 int yy = invert ? (height - 1 - y) : y; 240 int i = (yy * width + x) * comps; 241 fputc(ptr[i+rcomp], f); /* write red */ 242 fputc(ptr[i+gcomp], f); /* write green */ 243 fputc(ptr[i+bcomp], f); /* write blue */ 244 } 245 } 246 fclose(f); 247 } 248 else { 249 fprintf(stderr, "Unable to create %s in write_ppm()\n", filename); 250 } 251 } 252 253 254 /** 255 * Write a texture image to a ppm file. 256 * \param face cube face in [0,5] 257 * \param level mipmap level 258 */ 259 static void 260 write_texture_image(struct gl_texture_object *texObj, 261 GLuint face, GLuint level) 262 { 263 struct gl_texture_image *img = texObj->Image[face][level]; 264 if (img) { 265 GET_CURRENT_CONTEXT(ctx); 266 struct gl_pixelstore_attrib store; 267 GLubyte *buffer; 268 char s[100]; 269 270 buffer = malloc(img->Width * img->Height 271 * img->Depth * 4); 272 273 store = ctx->Pack; /* save */ 274 ctx->Pack = ctx->DefaultPacking; 275 276 ctx->Driver.GetTexSubImage(ctx, 277 0, 0, 0, img->Width, img->Height, img->Depth, 278 GL_RGBA, GL_UNSIGNED_BYTE, buffer, img); 279 280 /* make filename */ 281 _mesa_snprintf(s, sizeof(s), "/tmp/tex%u.l%u.f%u.ppm", texObj->Name, level, face); 282 283 printf(" Writing image level %u to %s\n", level, s); 284 write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE); 285 286 ctx->Pack = store; /* restore */ 287 288 free(buffer); 289 } 290 } 291 292 293 /** 294 * Write renderbuffer image to a ppm file. 295 */ 296 void 297 _mesa_write_renderbuffer_image(const struct gl_renderbuffer *rb) 298 { 299 GET_CURRENT_CONTEXT(ctx); 300 GLubyte *buffer; 301 char s[100]; 302 GLenum format, type; 303 304 if (rb->_BaseFormat == GL_RGB || 305 rb->_BaseFormat == GL_RGBA) { 306 format = GL_RGBA; 307 type = GL_UNSIGNED_BYTE; 308 } 309 else if (rb->_BaseFormat == GL_DEPTH_STENCIL) { 310 format = GL_DEPTH_STENCIL; 311 type = GL_UNSIGNED_INT_24_8; 312 } 313 else { 314 _mesa_debug(NULL, 315 "Unsupported BaseFormat 0x%x in " 316 "_mesa_write_renderbuffer_image()\n", 317 rb->_BaseFormat); 318 return; 319 } 320 321 buffer = malloc(rb->Width * rb->Height * 4); 322 323 ctx->Driver.ReadPixels(ctx, 0, 0, rb->Width, rb->Height, 324 format, type, &ctx->DefaultPacking, buffer); 325 326 /* make filename */ 327 _mesa_snprintf(s, sizeof(s), "/tmp/renderbuffer%u.ppm", rb->Name); 328 _mesa_snprintf(s, sizeof(s), "C:\\renderbuffer%u.ppm", rb->Name); 329 330 printf(" Writing renderbuffer image to %s\n", s); 331 332 _mesa_debug(NULL, " Writing renderbuffer image to %s\n", s); 333 334 write_ppm(s, buffer, rb->Width, rb->Height, 4, 0, 1, 2, GL_TRUE); 335 336 free(buffer); 337 } 338 339 340 /** How many texture images (mipmap levels, faces) to write to files */ 341 #define WRITE_NONE 0 342 #define WRITE_ONE 1 343 #define WRITE_ALL 2 344 345 static GLuint WriteImages; 346 347 348 static void 349 dump_texture(struct gl_texture_object *texObj, GLuint writeImages) 350 { 351 const GLuint numFaces = texObj->Target == GL_TEXTURE_CUBE_MAP ? 6 : 1; 352 GLboolean written = GL_FALSE; 353 GLuint i, j; 354 355 printf("Texture %u\n", texObj->Name); 356 printf(" Target %s\n", tex_target_name(texObj->Target)); 357 for (i = 0; i < MAX_TEXTURE_LEVELS; i++) { 358 for (j = 0; j < numFaces; j++) { 359 struct gl_texture_image *texImg = texObj->Image[j][i]; 360 if (texImg) { 361 printf(" Face %u level %u: %d x %d x %d, format %s\n", 362 j, i, 363 texImg->Width, texImg->Height, texImg->Depth, 364 _mesa_get_format_name(texImg->TexFormat)); 365 if (writeImages == WRITE_ALL || 366 (writeImages == WRITE_ONE && !written)) { 367 write_texture_image(texObj, j, i); 368 written = GL_TRUE; 369 } 370 } 371 } 372 } 373 } 374 375 376 /** 377 * Dump a single texture. 378 */ 379 void 380 _mesa_dump_texture(GLuint texture, GLuint writeImages) 381 { 382 GET_CURRENT_CONTEXT(ctx); 383 struct gl_texture_object *texObj = _mesa_lookup_texture(ctx, texture); 384 if (texObj) { 385 dump_texture(texObj, writeImages); 386 } 387 } 388 389 390 static void 391 dump_texture_cb(GLuint id, void *data, void *userData) 392 { 393 struct gl_texture_object *texObj = (struct gl_texture_object *) data; 394 (void) userData; 395 dump_texture(texObj, WriteImages); 396 } 397 398 399 /** 400 * Print basic info about all texture objext to stdout. 401 * If dumpImages is true, write PPM of level[0] image to a file. 402 */ 403 void 404 _mesa_dump_textures(GLuint writeImages) 405 { 406 GET_CURRENT_CONTEXT(ctx); 407 WriteImages = writeImages; 408 _mesa_HashWalk(ctx->Shared->TexObjects, dump_texture_cb, ctx); 409 } 410 411 412 static void 413 dump_renderbuffer(const struct gl_renderbuffer *rb, GLboolean writeImage) 414 { 415 printf("Renderbuffer %u: %u x %u IntFormat = %s\n", 416 rb->Name, rb->Width, rb->Height, 417 _mesa_enum_to_string(rb->InternalFormat)); 418 if (writeImage) { 419 _mesa_write_renderbuffer_image(rb); 420 } 421 } 422 423 424 static void 425 dump_renderbuffer_cb(GLuint id, void *data, void *userData) 426 { 427 const struct gl_renderbuffer *rb = (const struct gl_renderbuffer *) data; 428 (void) userData; 429 dump_renderbuffer(rb, WriteImages); 430 } 431 432 433 /** 434 * Print basic info about all renderbuffers to stdout. 435 * If dumpImages is true, write PPM of level[0] image to a file. 436 */ 437 void 438 _mesa_dump_renderbuffers(GLboolean writeImages) 439 { 440 GET_CURRENT_CONTEXT(ctx); 441 WriteImages = writeImages; 442 _mesa_HashWalk(ctx->Shared->RenderBuffers, dump_renderbuffer_cb, ctx); 443 } 444 445 446 447 void 448 _mesa_dump_color_buffer(const char *filename) 449 { 450 GET_CURRENT_CONTEXT(ctx); 451 const GLuint w = ctx->DrawBuffer->Width; 452 const GLuint h = ctx->DrawBuffer->Height; 453 GLubyte *buf; 454 455 buf = malloc(w * h * 4); 456 457 _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); 458 _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); 459 _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); 460 461 _mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf); 462 463 printf("ReadBuffer %p 0x%x DrawBuffer %p 0x%x\n", 464 (void *) ctx->ReadBuffer->_ColorReadBuffer, 465 ctx->ReadBuffer->ColorReadBuffer, 466 (void *) ctx->DrawBuffer->_ColorDrawBuffers[0], 467 ctx->DrawBuffer->ColorDrawBuffer[0]); 468 printf("Writing %d x %d color buffer to %s\n", w, h, filename); 469 write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE); 470 471 _mesa_PopClientAttrib(); 472 473 free(buf); 474 } 475 476 477 void 478 _mesa_dump_depth_buffer(const char *filename) 479 { 480 GET_CURRENT_CONTEXT(ctx); 481 const GLuint w = ctx->DrawBuffer->Width; 482 const GLuint h = ctx->DrawBuffer->Height; 483 GLuint *buf; 484 GLubyte *buf2; 485 GLuint i; 486 487 buf = malloc(w * h * 4); /* 4 bpp */ 488 buf2 = malloc(w * h * 3); /* 3 bpp */ 489 490 _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); 491 _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); 492 _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); 493 494 _mesa_ReadPixels(0, 0, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buf); 495 496 /* spread 24 bits of Z across R, G, B */ 497 for (i = 0; i < w * h; i++) { 498 buf2[i*3+0] = (buf[i] >> 24) & 0xff; 499 buf2[i*3+1] = (buf[i] >> 16) & 0xff; 500 buf2[i*3+2] = (buf[i] >> 8) & 0xff; 501 } 502 503 printf("Writing %d x %d depth buffer to %s\n", w, h, filename); 504 write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE); 505 506 _mesa_PopClientAttrib(); 507 508 free(buf); 509 free(buf2); 510 } 511 512 513 void 514 _mesa_dump_stencil_buffer(const char *filename) 515 { 516 GET_CURRENT_CONTEXT(ctx); 517 const GLuint w = ctx->DrawBuffer->Width; 518 const GLuint h = ctx->DrawBuffer->Height; 519 GLubyte *buf; 520 GLubyte *buf2; 521 GLuint i; 522 523 buf = malloc(w * h); /* 1 bpp */ 524 buf2 = malloc(w * h * 3); /* 3 bpp */ 525 526 _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); 527 _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1); 528 _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE); 529 530 _mesa_ReadPixels(0, 0, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf); 531 532 for (i = 0; i < w * h; i++) { 533 buf2[i*3+0] = buf[i]; 534 buf2[i*3+1] = (buf[i] & 127) * 2; 535 buf2[i*3+2] = (buf[i] - 128) * 2; 536 } 537 538 printf("Writing %d x %d stencil buffer to %s\n", w, h, filename); 539 write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE); 540 541 _mesa_PopClientAttrib(); 542 543 free(buf); 544 free(buf2); 545 } 546 547 548 void 549 _mesa_dump_image(const char *filename, const void *image, GLuint w, GLuint h, 550 GLenum format, GLenum type) 551 { 552 GLboolean invert = GL_TRUE; 553 554 if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) { 555 write_ppm(filename, image, w, h, 4, 0, 1, 2, invert); 556 } 557 else if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) { 558 write_ppm(filename, image, w, h, 4, 2, 1, 0, invert); 559 } 560 else if (format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE) { 561 write_ppm(filename, image, w, h, 2, 1, 0, 0, invert); 562 } 563 else if (format == GL_RED && type == GL_UNSIGNED_BYTE) { 564 write_ppm(filename, image, w, h, 1, 0, 0, 0, invert); 565 } 566 else if (format == GL_RGBA && type == GL_FLOAT) { 567 /* convert floats to ubyte */ 568 GLubyte *buf = malloc(w * h * 4 * sizeof(GLubyte)); 569 const GLfloat *f = (const GLfloat *) image; 570 GLuint i; 571 for (i = 0; i < w * h * 4; i++) { 572 UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]); 573 } 574 write_ppm(filename, buf, w, h, 4, 0, 1, 2, invert); 575 free(buf); 576 } 577 else if (format == GL_RED && type == GL_FLOAT) { 578 /* convert floats to ubyte */ 579 GLubyte *buf = malloc(w * h * sizeof(GLubyte)); 580 const GLfloat *f = (const GLfloat *) image; 581 GLuint i; 582 for (i = 0; i < w * h; i++) { 583 UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]); 584 } 585 write_ppm(filename, buf, w, h, 1, 0, 0, 0, invert); 586 free(buf); 587 } 588 else { 589 _mesa_problem(NULL, 590 "Unsupported format 0x%x / type 0x%x in _mesa_dump_image()", 591 format, type); 592 } 593 } 594 595 596 /** 597 * Quick and dirty function to "print" a texture to stdout. 598 */ 599 void 600 _mesa_print_texture(struct gl_context *ctx, struct gl_texture_image *img) 601 { 602 const GLint slice = 0; 603 GLint srcRowStride; 604 GLuint i, j, c; 605 GLubyte *data; 606 607 ctx->Driver.MapTextureImage(ctx, img, slice, 608 0, 0, img->Width, img->Height, GL_MAP_READ_BIT, 609 &data, &srcRowStride); 610 611 if (!data) { 612 printf("No texture data\n"); 613 } 614 else { 615 /* XXX add more formats or make into a new format utility function */ 616 switch (img->TexFormat) { 617 case MESA_FORMAT_A_UNORM8: 618 case MESA_FORMAT_L_UNORM8: 619 case MESA_FORMAT_I_UNORM8: 620 c = 1; 621 break; 622 case MESA_FORMAT_L8A8_UNORM: 623 case MESA_FORMAT_A8L8_UNORM: 624 c = 2; 625 break; 626 case MESA_FORMAT_BGR_UNORM8: 627 case MESA_FORMAT_RGB_UNORM8: 628 c = 3; 629 break; 630 case MESA_FORMAT_A8B8G8R8_UNORM: 631 case MESA_FORMAT_B8G8R8A8_UNORM: 632 c = 4; 633 break; 634 default: 635 _mesa_problem(NULL, "error in PrintTexture\n"); 636 return; 637 } 638 639 for (i = 0; i < img->Height; i++) { 640 for (j = 0; j < img->Width; j++) { 641 if (c==1) 642 printf("%02x ", data[0]); 643 else if (c==2) 644 printf("%02x%02x ", data[0], data[1]); 645 else if (c==3) 646 printf("%02x%02x%02x ", data[0], data[1], data[2]); 647 else if (c==4) 648 printf("%02x%02x%02x%02x ", data[0], data[1], data[2], data[3]); 649 data += (srcRowStride - img->Width) * c; 650 } 651 /* XXX use img->ImageStride here */ 652 printf("\n"); 653 654 } 655 } 656 657 ctx->Driver.UnmapTextureImage(ctx, img, slice); 658 } 659
