src/mesa/main/debug.c

   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 "errors.h"
  28 #include "mtypes.h"
  29 #include "attrib.h"
  30 #include "enums.h"
  31 #include "formats.h"
  32 #include "hash.h"
  33
  34 #include "macros.h"
  35 #include "debug.h"
  36 #include "get.h"
  37 #include "pixelstore.h"
  38 #include "readpix.h"
  39 #include "texobj.h"
  40
  41
  42 static const char *
  43 tex_target_name(GLenum tgt)
  44 {
  45    static const struct {
  46       GLenum target;
  47       const char *name;
  48    } tex_targets[] = {
  49       { GL_TEXTURE_1D, "GL_TEXTURE_1D" },
  50       { GL_TEXTURE_2D, "GL_TEXTURE_2D" },
  51       { GL_TEXTURE_3D, "GL_TEXTURE_3D" },
  52       { GL_TEXTURE_CUBE_MAP, "GL_TEXTURE_CUBE_MAP" },
  53       { GL_TEXTURE_RECTANGLE, "GL_TEXTURE_RECTANGLE" },
  54       { GL_TEXTURE_1D_ARRAY_EXT, "GL_TEXTURE_1D_ARRAY" },
  55       { GL_TEXTURE_2D_ARRAY_EXT, "GL_TEXTURE_2D_ARRAY" },
  56       { GL_TEXTURE_CUBE_MAP_ARRAY, "GL_TEXTURE_CUBE_MAP_ARRAY" },
  57       { GL_TEXTURE_BUFFER, "GL_TEXTURE_BUFFER" },
  58       { GL_TEXTURE_2D_MULTISAMPLE, "GL_TEXTURE_2D_MULTISAMPLE" },
  59       { GL_TEXTURE_2D_MULTISAMPLE_ARRAY, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY" },
  60       { GL_TEXTURE_EXTERNAL_OES, "GL_TEXTURE_EXTERNAL_OES" }
  61    };
  62    GLuint i;
  63    STATIC_ASSERT(ARRAY_SIZE(tex_targets) == NUM_TEXTURE_TARGETS);
  64    for (i = 0; i < ARRAY_SIZE(tex_targets); i++) {
  65       if (tex_targets[i].target == tgt)
  66          return tex_targets[i].name;
  67    }
  68    return "UNKNOWN TEX TARGET";
  69 }
  70
  71
  72 void
  73 _mesa_print_state( const char *msg, GLuint state )
  74 {
  75    _mesa_debug(NULL,
  76            "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
  77            msg,
  78            state,
  79            (state & _NEW_MODELVIEW)       ? "ctx->ModelView, " : "",
  80            (state & _NEW_PROJECTION)      ? "ctx->Projection, " : "",
  81            (state & _NEW_TEXTURE_MATRIX)  ? "ctx->TextureMatrix, " : "",
  82            (state & _NEW_COLOR)           ? "ctx->Color, " : "",
  83            (state & _NEW_DEPTH)           ? "ctx->Depth, " : "",
  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_OBJECT)  ? "ctx->Texture(Object), " : "",
  95            (state & _NEW_TRANSFORM)       ? "ctx->Transform, " : "",
  96            (state & _NEW_VIEWPORT)        ? "ctx->Viewport, " : "",
  97            (state & _NEW_TEXTURE_STATE)   ? "ctx->Texture(State), " : "",
  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 #ifndef NDEBUG
 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 #ifndef NDEBUG
 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       if (!f) {
 238          fprintf(stderr, "Error while reopening %s in write_ppm()\n",
 239                  filename);
 240          return;
 241       }
 242       for (y=0; y < height; y++) {
 243          for (x = 0; x < width; x++) {
 244             int yy = invert ? (height - 1 - y) : y;
 245             int i = (yy * width + x) * comps;
 246             fputc(ptr[i+rcomp], f); /* write red */
 247             fputc(ptr[i+gcomp], f); /* write green */
 248             fputc(ptr[i+bcomp], f); /* write blue */
 249          }
 250       }
 251       fclose(f);
 252    }
 253    else {
 254       fprintf(stderr, "Unable to create %s in write_ppm()\n", filename);
 255    }
 256 }
 257
 258
 259 /**
 260  * Write a texture image to a ppm file.
 261  * \param face  cube face in [0,5]
 262  * \param level  mipmap level
 263  */
 264 static void
 265 write_texture_image(struct gl_texture_object *texObj,
 266                     GLuint face, GLuint level)
 267 {
 268    struct gl_texture_image *img = texObj->Image[face][level];
 269    if (img) {
 270       GET_CURRENT_CONTEXT(ctx);
 271       struct gl_pixelstore_attrib store;
 272       GLubyte *buffer;
 273       char s[100];
 274
 275       buffer = malloc(img->Width * img->Height
 276                                         * img->Depth * 4);
 277
 278       store = ctx->Pack; /* save */
 279       ctx->Pack = ctx->DefaultPacking;
 280
 281       ctx->Driver.GetTexSubImage(ctx,
 282                                  0, 0, 0, img->Width, img->Height, img->Depth,
 283                                  GL_RGBA, GL_UNSIGNED_BYTE, buffer, img);
 284
 285       /* make filename */
 286       snprintf(s, sizeof(s), "/tmp/tex%u.l%u.f%u.ppm", texObj->Name, level, face);
 287
 288       printf("  Writing image level %u to %s\n", level, s);
 289       write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE);
 290
 291       ctx->Pack = store; /* restore */
 292
 293       free(buffer);
 294    }
 295 }
 296
 297
 298 /**
 299  * Write renderbuffer image to a ppm file.
 300  */
 301 void
 302 _mesa_write_renderbuffer_image(const struct gl_renderbuffer *rb)
 303 {
 304    GET_CURRENT_CONTEXT(ctx);
 305    GLubyte *buffer;
 306    char s[100];
 307    GLenum format, type;
 308
 309    if (rb->_BaseFormat == GL_RGB ||
 310        rb->_BaseFormat == GL_RGBA) {
 311       format = GL_RGBA;
 312       type = GL_UNSIGNED_BYTE;
 313    }
 314    else if (rb->_BaseFormat == GL_DEPTH_STENCIL) {
 315       format = GL_DEPTH_STENCIL;
 316       type = GL_UNSIGNED_INT_24_8;
 317    }
 318    else {
 319       _mesa_debug(NULL,
 320                   "Unsupported BaseFormat 0x%x in "
 321                   "_mesa_write_renderbuffer_image()\n",
 322                   rb->_BaseFormat);
 323       return;
 324    }
 325
 326    buffer = malloc(rb->Width * rb->Height * 4);
 327
 328    ctx->Driver.ReadPixels(ctx, 0, 0, rb->Width, rb->Height,
 329                           format, type, &ctx->DefaultPacking, buffer);
 330
 331    /* make filename */
 332    snprintf(s, sizeof(s), "/tmp/renderbuffer%u.ppm", rb->Name);
 333    snprintf(s, sizeof(s), "C:\\renderbuffer%u.ppm", rb->Name);
 334
 335    printf("  Writing renderbuffer image to %s\n", s);
 336
 337    _mesa_debug(NULL, "  Writing renderbuffer image to %s\n", s);
 338
 339    write_ppm(s, buffer, rb->Width, rb->Height, 4, 0, 1, 2, GL_TRUE);
 340
 341    free(buffer);
 342 }
 343
 344
 345 /** How many texture images (mipmap levels, faces) to write to files */
 346 #define WRITE_NONE 0
 347 #define WRITE_ONE  1
 348 #define WRITE_ALL  2
 349
 350 static GLuint WriteImages;
 351
 352
 353 static void
 354 dump_texture(struct gl_texture_object *texObj, GLuint writeImages)
 355 {
 356    const GLuint numFaces = texObj->Target == GL_TEXTURE_CUBE_MAP ? 6 : 1;
 357    GLboolean written = GL_FALSE;
 358    GLuint i, j;
 359
 360    printf("Texture %u\n", texObj->Name);
 361    printf("  Target %s\n", tex_target_name(texObj->Target));
 362    for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
 363       for (j = 0; j < numFaces; j++) {
 364          struct gl_texture_image *texImg = texObj->Image[j][i];
 365          if (texImg) {
 366             printf("  Face %u level %u: %d x %d x %d, format %s\n",
 367                    j, i,
 368                    texImg->Width, texImg->Height, texImg->Depth,
 369                    _mesa_get_format_name(texImg->TexFormat));
 370             if (writeImages == WRITE_ALL ||
 371                 (writeImages == WRITE_ONE && !written)) {
 372                write_texture_image(texObj, j, i);
 373                written = GL_TRUE;
 374             }
 375          }
 376       }
 377    }
 378 }
 379
 380
 381 /**
 382  * Dump a single texture.
 383  */
 384 void
 385 _mesa_dump_texture(GLuint texture, GLuint writeImages)
 386 {
 387    GET_CURRENT_CONTEXT(ctx);
 388    struct gl_texture_object *texObj = _mesa_lookup_texture(ctx, texture);
 389    if (texObj) {
 390       dump_texture(texObj, writeImages);
 391    }
 392 }
 393
 394
 395 static void
 396 dump_texture_cb(GLuint id, void *data, void *userData)
 397 {
 398    struct gl_texture_object *texObj = (struct gl_texture_object *) data;
 399    (void) userData;
 400    dump_texture(texObj, WriteImages);
 401 }
 402
 403
 404 /**
 405  * Print basic info about all texture objext to stdout.
 406  * If dumpImages is true, write PPM of level[0] image to a file.
 407  */
 408 void
 409 _mesa_dump_textures(GLuint writeImages)
 410 {
 411    GET_CURRENT_CONTEXT(ctx);
 412    WriteImages = writeImages;
 413    _mesa_HashWalk(ctx->Shared->TexObjects, dump_texture_cb, ctx);
 414 }
 415
 416
 417 static void
 418 dump_renderbuffer(const struct gl_renderbuffer *rb, GLboolean writeImage)
 419 {
 420    printf("Renderbuffer %u: %u x %u  IntFormat = %s\n",
 421           rb->Name, rb->Width, rb->Height,
 422           _mesa_enum_to_string(rb->InternalFormat));
 423    if (writeImage) {
 424       _mesa_write_renderbuffer_image(rb);
 425    }
 426 }
 427
 428
 429 static void
 430 dump_renderbuffer_cb(GLuint id, void *data, void *userData)
 431 {
 432    const struct gl_renderbuffer *rb = (const struct gl_renderbuffer *) data;
 433    (void) userData;
 434    dump_renderbuffer(rb, WriteImages);
 435 }
 436
 437
 438 /**
 439  * Print basic info about all renderbuffers to stdout.
 440  * If dumpImages is true, write PPM of level[0] image to a file.
 441  */
 442 void
 443 _mesa_dump_renderbuffers(GLboolean writeImages)
 444 {
 445    GET_CURRENT_CONTEXT(ctx);
 446    WriteImages = writeImages;
 447    _mesa_HashWalk(ctx->Shared->RenderBuffers, dump_renderbuffer_cb, ctx);
 448 }
 449
 450
 451
 452 void
 453 _mesa_dump_color_buffer(const char *filename)
 454 {
 455    GET_CURRENT_CONTEXT(ctx);
 456    const GLuint w = ctx->DrawBuffer->Width;
 457    const GLuint h = ctx->DrawBuffer->Height;
 458    GLubyte *buf;
 459
 460    buf = malloc(w * h * 4);
 461
 462    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 463    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 464    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 465
 466    _mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
 467
 468    printf("ReadBuffer %p 0x%x  DrawBuffer %p 0x%x\n",
 469           (void *) ctx->ReadBuffer->_ColorReadBuffer,
 470           ctx->ReadBuffer->ColorReadBuffer,
 471           (void *) ctx->DrawBuffer->_ColorDrawBuffers[0],
 472           ctx->DrawBuffer->ColorDrawBuffer[0]);
 473    printf("Writing %d x %d color buffer to %s\n", w, h, filename);
 474    write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE);
 475
 476    _mesa_PopClientAttrib();
 477
 478    free(buf);
 479 }
 480
 481
 482 void
 483 _mesa_dump_depth_buffer(const char *filename)
 484 {
 485    GET_CURRENT_CONTEXT(ctx);
 486    const GLuint w = ctx->DrawBuffer->Width;
 487    const GLuint h = ctx->DrawBuffer->Height;
 488    GLuint *buf;
 489    GLubyte *buf2;
 490    GLuint i;
 491
 492    buf = malloc(w * h * 4);  /* 4 bpp */
 493    buf2 = malloc(w * h * 3); /* 3 bpp */
 494
 495    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 496    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 497    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 498
 499    _mesa_ReadPixels(0, 0, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buf);
 500
 501    /* spread 24 bits of Z across R, G, B */
 502    for (i = 0; i < w * h; i++) {
 503       buf2[i*3+0] = (buf[i] >> 24) & 0xff;
 504       buf2[i*3+1] = (buf[i] >> 16) & 0xff;
 505       buf2[i*3+2] = (buf[i] >>  8) & 0xff;
 506    }
 507
 508    printf("Writing %d x %d depth buffer to %s\n", w, h, filename);
 509    write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
 510
 511    _mesa_PopClientAttrib();
 512
 513    free(buf);
 514    free(buf2);
 515 }
 516
 517
 518 void
 519 _mesa_dump_stencil_buffer(const char *filename)
 520 {
 521    GET_CURRENT_CONTEXT(ctx);
 522    const GLuint w = ctx->DrawBuffer->Width;
 523    const GLuint h = ctx->DrawBuffer->Height;
 524    GLubyte *buf;
 525    GLubyte *buf2;
 526    GLuint i;
 527
 528    buf = malloc(w * h);  /* 1 bpp */
 529    buf2 = malloc(w * h * 3); /* 3 bpp */
 530
 531    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 532    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 533    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 534
 535    _mesa_ReadPixels(0, 0, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf);
 536
 537    for (i = 0; i < w * h; i++) {
 538       buf2[i*3+0] = buf[i];
 539       buf2[i*3+1] = (buf[i] & 127) * 2;
 540       buf2[i*3+2] = (buf[i] - 128) * 2;
 541    }
 542
 543    printf("Writing %d x %d stencil buffer to %s\n", w, h, filename);
 544    write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
 545
 546    _mesa_PopClientAttrib();
 547
 548    free(buf);
 549    free(buf2);
 550 }
 551
 552
 553 void
 554 _mesa_dump_image(const char *filename, const void *image, GLuint w, GLuint h,
 555                  GLenum format, GLenum type)
 556 {
 557    GLboolean invert = GL_TRUE;
 558
 559    if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
 560       write_ppm(filename, image, w, h, 4, 0, 1, 2, invert);
 561    }
 562    else if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) {
 563       write_ppm(filename, image, w, h, 4, 2, 1, 0, invert);
 564    }
 565    else if (format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE) {
 566       write_ppm(filename, image, w, h, 2, 1, 0, 0, invert);
 567    }
 568    else if (format == GL_RED && type == GL_UNSIGNED_BYTE) {
 569       write_ppm(filename, image, w, h, 1, 0, 0, 0, invert);
 570    }
 571    else if (format == GL_RGBA && type == GL_FLOAT) {
 572       /* convert floats to ubyte */
 573       GLubyte *buf = malloc(w * h * 4 * sizeof(GLubyte));
 574       const GLfloat *f = (const GLfloat *) image;
 575       GLuint i;
 576       for (i = 0; i < w * h * 4; i++) {
 577          UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]);
 578       }
 579       write_ppm(filename, buf, w, h, 4, 0, 1, 2, invert);
 580       free(buf);
 581    }
 582    else if (format == GL_RED && type == GL_FLOAT) {
 583       /* convert floats to ubyte */
 584       GLubyte *buf = malloc(w * h * sizeof(GLubyte));
 585       const GLfloat *f = (const GLfloat *) image;
 586       GLuint i;
 587       for (i = 0; i < w * h; i++) {
 588          UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]);
 589       }
 590       write_ppm(filename, buf, w, h, 1, 0, 0, 0, invert);
 591       free(buf);
 592    }
 593    else {
 594       _mesa_problem(NULL,
 595                  "Unsupported format 0x%x / type 0x%x in _mesa_dump_image()",
 596                  format, type);
 597    }
 598 }
 599
 600
 601 /**
 602  * Quick and dirty function to "print" a texture to stdout.
 603  */
 604 void
 605 _mesa_print_texture(struct gl_context *ctx, struct gl_texture_image *img)
 606 {
 607    const GLint slice = 0;
 608    GLint srcRowStride;
 609    GLuint i, j, c;
 610    GLubyte *data;
 611
 612    ctx->Driver.MapTextureImage(ctx, img, slice,
 613                                0, 0, img->Width, img->Height, GL_MAP_READ_BIT,
 614                                &data, &srcRowStride);
 615
 616    if (!data) {
 617       printf("No texture data\n");
 618    }
 619    else {
 620       /* XXX add more formats or make into a new format utility function */
 621       switch (img->TexFormat) {
 622          case MESA_FORMAT_A_UNORM8:
 623          case MESA_FORMAT_L_UNORM8:
 624          case MESA_FORMAT_I_UNORM8:
 625             c = 1;
 626             break;
 627          case MESA_FORMAT_LA_UNORM8:
 628             c = 2;
 629             break;
 630          case MESA_FORMAT_BGR_UNORM8:
 631          case MESA_FORMAT_RGB_UNORM8:
 632             c = 3;
 633             break;
 634          case MESA_FORMAT_A8B8G8R8_UNORM:
 635          case MESA_FORMAT_B8G8R8A8_UNORM:
 636             c = 4;
 637             break;
 638          default:
 639             _mesa_problem(NULL, "error in PrintTexture\n");
 640             return;
 641       }
 642
 643       for (i = 0; i < img->Height; i++) {
 644          for (j = 0; j < img->Width; j++) {
 645             if (c==1)
 646                printf("%02x  ", data[0]);
 647             else if (c==2)
 648                printf("%02x%02x  ", data[0], data[1]);
 649             else if (c==3)
 650                printf("%02x%02x%02x  ", data[0], data[1], data[2]);
 651             else if (c==4)
 652                printf("%02x%02x%02x%02x  ", data[0], data[1], data[2], data[3]);
 653             data += (srcRowStride - img->Width) * c;
 654          }
 655          /* XXX use img->ImageStride here */
 656          printf("\n");
 657
 658       }
 659    }
 660
 661    ctx->Driver.UnmapTextureImage(ctx, img, slice);
 662 }