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 "mtypes.h"
  28 #include "attrib.h"
  29 #include "colormac.h"
  30 #include "enums.h"
  31 #include "formats.h"
  32 #include "hash.h"
  33 #include "imports.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(THREADS)
 122    _mesa_debug(NULL, "Mesa thread-safe: YES\n");
 123 #else
 124    _mesa_debug(NULL, "Mesa thread-safe: NO\n");
 125 #endif
 126 #if defined(USE_X86_ASM)
 127    _mesa_debug(NULL, "Mesa x86-optimized: YES\n");
 128 #else
 129    _mesa_debug(NULL, "Mesa x86-optimized: NO\n");
 130 #endif
 131 #if defined(USE_SPARC_ASM)
 132    _mesa_debug(NULL, "Mesa sparc-optimized: YES\n");
 133 #else
 134    _mesa_debug(NULL, "Mesa sparc-optimized: NO\n");
 135 #endif
 136 }
 137
 138
 139 /**
 140  * Set verbose logging flags.  When these flags are set, GL API calls
 141  * in the various categories will be printed to stderr.
 142  * \param str  a comma-separated list of keywords
 143  */
 144 static void
 145 set_verbose_flags(const char *str)
 146 {
 147 #ifdef DEBUG
 148    struct option {
 149       const char *name;
 150       GLbitfield flag;
 151    };
 152    static const struct option opts[] = {
 153       { "varray",    VERBOSE_VARRAY },
 154       { "tex",       VERBOSE_TEXTURE },
 155       { "mat",       VERBOSE_MATERIAL },
 156       { "pipe",      VERBOSE_PIPELINE },
 157       { "driver",    VERBOSE_DRIVER },
 158       { "state",     VERBOSE_STATE },
 159       { "api",       VERBOSE_API },
 160       { "list",      VERBOSE_DISPLAY_LIST },
 161       { "lighting",  VERBOSE_LIGHTING },
 162       { "disassem",  VERBOSE_DISASSEM },
 163       { "draw",      VERBOSE_DRAW },
 164       { "swap",      VERBOSE_SWAPBUFFERS }
 165    };
 166    GLuint i;
 167
 168    if (!str)
 169       return;
 170
 171    MESA_VERBOSE = 0x0;
 172    for (i = 0; i < ARRAY_SIZE(opts); i++) {
 173       if (strstr(str, opts[i].name) || strcmp(str, "all") == 0)
 174          MESA_VERBOSE |= opts[i].flag;
 175    }
 176 #endif
 177 }
 178
 179
 180 /**
 181  * Set debugging flags.  When these flags are set, Mesa will do additional
 182  * debug checks or actions.
 183  * \param str  a comma-separated list of keywords
 184  */
 185 static void
 186 set_debug_flags(const char *str)
 187 {
 188 #ifdef DEBUG
 189    struct option {
 190       const char *name;
 191       GLbitfield flag;
 192    };
 193    static const struct option opts[] = {
 194       { "silent", DEBUG_SILENT }, /* turn off debug messages */
 195       { "flush", DEBUG_ALWAYS_FLUSH }, /* flush after each drawing command */
 196       { "incomplete_tex", DEBUG_INCOMPLETE_TEXTURE },
 197       { "incomplete_fbo", DEBUG_INCOMPLETE_FBO }
 198    };
 199    GLuint i;
 200
 201    if (!str)
 202       return;
 203
 204    MESA_DEBUG_FLAGS = 0x0;
 205    for (i = 0; i < ARRAY_SIZE(opts); i++) {
 206       if (strstr(str, opts[i].name))
 207          MESA_DEBUG_FLAGS |= opts[i].flag;
 208    }
 209 #endif
 210 }
 211
 212
 213 /**
 214  * Initialize debugging variables from env vars.
 215  */
 216 void
 217 _mesa_init_debug( struct gl_context *ctx )
 218 {
 219    set_debug_flags(getenv("MESA_DEBUG"));
 220    set_verbose_flags(getenv("MESA_VERBOSE"));
 221 }
 222
 223
 224 /*
 225  * Write ppm file
 226  */
 227 static void
 228 write_ppm(const char *filename, const GLubyte *buffer, int width, int height,
 229           int comps, int rcomp, int gcomp, int bcomp, GLboolean invert)
 230 {
 231    FILE *f = fopen( filename, "w" );
 232    if (f) {
 233       int x, y;
 234       const GLubyte *ptr = buffer;
 235       fprintf(f,"P6\n");
 236       fprintf(f,"# ppm-file created by osdemo.c\n");
 237       fprintf(f,"%i %i\n", width,height);
 238       fprintf(f,"255\n");
 239       fclose(f);
 240       f = fopen( filename, "ab" );  /* reopen in binary append mode */
 241       for (y=0; y < height; y++) {
 242          for (x = 0; x < width; x++) {
 243             int yy = invert ? (height - 1 - y) : y;
 244             int i = (yy * width + x) * comps;
 245             fputc(ptr[i+rcomp], f); /* write red */
 246             fputc(ptr[i+gcomp], f); /* write green */
 247             fputc(ptr[i+bcomp], f); /* write blue */
 248          }
 249       }
 250       fclose(f);
 251    }
 252    else {
 253       fprintf(stderr, "Unable to create %s in write_ppm()\n", filename);
 254    }
 255 }
 256
 257
 258 /**
 259  * Write a texture image to a ppm file.
 260  * \param face  cube face in [0,5]
 261  * \param level  mipmap level
 262  */
 263 static void
 264 write_texture_image(struct gl_texture_object *texObj,
 265                     GLuint face, GLuint level)
 266 {
 267    struct gl_texture_image *img = texObj->Image[face][level];
 268    if (img) {
 269       GET_CURRENT_CONTEXT(ctx);
 270       struct gl_pixelstore_attrib store;
 271       GLubyte *buffer;
 272       char s[100];
 273
 274       buffer = malloc(img->Width * img->Height
 275                                         * img->Depth * 4);
 276
 277       store = ctx->Pack; /* save */
 278       ctx->Pack = ctx->DefaultPacking;
 279
 280       ctx->Driver.GetTexImage(ctx, GL_RGBA, GL_UNSIGNED_BYTE, buffer, img);
 281
 282       /* make filename */
 283       _mesa_snprintf(s, sizeof(s), "/tmp/tex%u.l%u.f%u.ppm", texObj->Name, level, face);
 284
 285       printf("  Writing image level %u to %s\n", level, s);
 286       write_ppm(s, buffer, img->Width, img->Height, 4, 0, 1, 2, GL_FALSE);
 287
 288       ctx->Pack = store; /* restore */
 289
 290       free(buffer);
 291    }
 292 }
 293
 294
 295 /**
 296  * Write renderbuffer image to a ppm file.
 297  */
 298 void
 299 _mesa_write_renderbuffer_image(const struct gl_renderbuffer *rb)
 300 {
 301    GET_CURRENT_CONTEXT(ctx);
 302    GLubyte *buffer;
 303    char s[100];
 304    GLenum format, type;
 305
 306    if (rb->_BaseFormat == GL_RGB ||
 307        rb->_BaseFormat == GL_RGBA) {
 308       format = GL_RGBA;
 309       type = GL_UNSIGNED_BYTE;
 310    }
 311    else if (rb->_BaseFormat == GL_DEPTH_STENCIL) {
 312       format = GL_DEPTH_STENCIL;
 313       type = GL_UNSIGNED_INT_24_8;
 314    }
 315    else {
 316       _mesa_debug(NULL,
 317                   "Unsupported BaseFormat 0x%x in "
 318                   "_mesa_write_renderbuffer_image()\n",
 319                   rb->_BaseFormat);
 320       return;
 321    }
 322
 323    buffer = malloc(rb->Width * rb->Height * 4);
 324
 325    ctx->Driver.ReadPixels(ctx, 0, 0, rb->Width, rb->Height,
 326                           format, type, &ctx->DefaultPacking, buffer);
 327
 328    /* make filename */
 329    _mesa_snprintf(s, sizeof(s), "/tmp/renderbuffer%u.ppm", rb->Name);
 330    _mesa_snprintf(s, sizeof(s), "C:\\renderbuffer%u.ppm", rb->Name);
 331
 332    printf("  Writing renderbuffer image to %s\n", s);
 333
 334    _mesa_debug(NULL, "  Writing renderbuffer image to %s\n", s);
 335
 336    write_ppm(s, buffer, rb->Width, rb->Height, 4, 0, 1, 2, GL_TRUE);
 337
 338    free(buffer);
 339 }
 340
 341
 342 /** How many texture images (mipmap levels, faces) to write to files */
 343 #define WRITE_NONE 0
 344 #define WRITE_ONE  1
 345 #define WRITE_ALL  2
 346
 347 static GLuint WriteImages;
 348
 349
 350 static void
 351 dump_texture(struct gl_texture_object *texObj, GLuint writeImages)
 352 {
 353    const GLuint numFaces = texObj->Target == GL_TEXTURE_CUBE_MAP ? 6 : 1;
 354    GLboolean written = GL_FALSE;
 355    GLuint i, j;
 356
 357    printf("Texture %u\n", texObj->Name);
 358    printf("  Target %s\n", tex_target_name(texObj->Target));
 359    for (i = 0; i < MAX_TEXTURE_LEVELS; i++) {
 360       for (j = 0; j < numFaces; j++) {
 361          struct gl_texture_image *texImg = texObj->Image[j][i];
 362          if (texImg) {
 363             printf("  Face %u level %u: %d x %d x %d, format %s\n",
 364                    j, i,
 365                    texImg->Width, texImg->Height, texImg->Depth,
 366                    _mesa_get_format_name(texImg->TexFormat));
 367             if (writeImages == WRITE_ALL ||
 368                 (writeImages == WRITE_ONE && !written)) {
 369                write_texture_image(texObj, j, i);
 370                written = GL_TRUE;
 371             }
 372          }
 373       }
 374    }
 375 }
 376
 377
 378 /**
 379  * Dump a single texture.
 380  */
 381 void
 382 _mesa_dump_texture(GLuint texture, GLuint writeImages)
 383 {
 384    GET_CURRENT_CONTEXT(ctx);
 385    struct gl_texture_object *texObj = _mesa_lookup_texture(ctx, texture);
 386    if (texObj) {
 387       dump_texture(texObj, writeImages);
 388    }
 389 }
 390
 391
 392 static void
 393 dump_texture_cb(GLuint id, void *data, void *userData)
 394 {
 395    struct gl_texture_object *texObj = (struct gl_texture_object *) data;
 396    (void) userData;
 397    dump_texture(texObj, WriteImages);
 398 }
 399
 400
 401 /**
 402  * Print basic info about all texture objext to stdout.
 403  * If dumpImages is true, write PPM of level[0] image to a file.
 404  */
 405 void
 406 _mesa_dump_textures(GLuint writeImages)
 407 {
 408    GET_CURRENT_CONTEXT(ctx);
 409    WriteImages = writeImages;
 410    _mesa_HashWalk(ctx->Shared->TexObjects, dump_texture_cb, ctx);
 411 }
 412
 413
 414 static void
 415 dump_renderbuffer(const struct gl_renderbuffer *rb, GLboolean writeImage)
 416 {
 417    printf("Renderbuffer %u: %u x %u  IntFormat = %s\n",
 418           rb->Name, rb->Width, rb->Height,
 419           _mesa_lookup_enum_by_nr(rb->InternalFormat));
 420    if (writeImage) {
 421       _mesa_write_renderbuffer_image(rb);
 422    }
 423 }
 424
 425
 426 static void
 427 dump_renderbuffer_cb(GLuint id, void *data, void *userData)
 428 {
 429    const struct gl_renderbuffer *rb = (const struct gl_renderbuffer *) data;
 430    (void) userData;
 431    dump_renderbuffer(rb, WriteImages);
 432 }
 433
 434
 435 /**
 436  * Print basic info about all renderbuffers to stdout.
 437  * If dumpImages is true, write PPM of level[0] image to a file.
 438  */
 439 void
 440 _mesa_dump_renderbuffers(GLboolean writeImages)
 441 {
 442    GET_CURRENT_CONTEXT(ctx);
 443    WriteImages = writeImages;
 444    _mesa_HashWalk(ctx->Shared->RenderBuffers, dump_renderbuffer_cb, ctx);
 445 }
 446
 447
 448
 449 void
 450 _mesa_dump_color_buffer(const char *filename)
 451 {
 452    GET_CURRENT_CONTEXT(ctx);
 453    const GLuint w = ctx->DrawBuffer->Width;
 454    const GLuint h = ctx->DrawBuffer->Height;
 455    GLubyte *buf;
 456
 457    buf = malloc(w * h * 4);
 458
 459    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 460    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 461    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 462
 463    _mesa_ReadPixels(0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, buf);
 464
 465    printf("ReadBuffer %p 0x%x  DrawBuffer %p 0x%x\n",
 466           (void *) ctx->ReadBuffer->_ColorReadBuffer,
 467           ctx->ReadBuffer->ColorReadBuffer,
 468           (void *) ctx->DrawBuffer->_ColorDrawBuffers[0],
 469           ctx->DrawBuffer->ColorDrawBuffer[0]);
 470    printf("Writing %d x %d color buffer to %s\n", w, h, filename);
 471    write_ppm(filename, buf, w, h, 4, 0, 1, 2, GL_TRUE);
 472
 473    _mesa_PopClientAttrib();
 474
 475    free(buf);
 476 }
 477
 478
 479 void
 480 _mesa_dump_depth_buffer(const char *filename)
 481 {
 482    GET_CURRENT_CONTEXT(ctx);
 483    const GLuint w = ctx->DrawBuffer->Width;
 484    const GLuint h = ctx->DrawBuffer->Height;
 485    GLuint *buf;
 486    GLubyte *buf2;
 487    GLuint i;
 488
 489    buf = malloc(w * h * 4);  /* 4 bpp */
 490    buf2 = malloc(w * h * 3); /* 3 bpp */
 491
 492    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 493    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 494    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 495
 496    _mesa_ReadPixels(0, 0, w, h, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, buf);
 497
 498    /* spread 24 bits of Z across R, G, B */
 499    for (i = 0; i < w * h; i++) {
 500       buf2[i*3+0] = (buf[i] >> 24) & 0xff;
 501       buf2[i*3+1] = (buf[i] >> 16) & 0xff;
 502       buf2[i*3+2] = (buf[i] >>  8) & 0xff;
 503    }
 504
 505    printf("Writing %d x %d depth buffer to %s\n", w, h, filename);
 506    write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
 507
 508    _mesa_PopClientAttrib();
 509
 510    free(buf);
 511    free(buf2);
 512 }
 513
 514
 515 void
 516 _mesa_dump_stencil_buffer(const char *filename)
 517 {
 518    GET_CURRENT_CONTEXT(ctx);
 519    const GLuint w = ctx->DrawBuffer->Width;
 520    const GLuint h = ctx->DrawBuffer->Height;
 521    GLubyte *buf;
 522    GLubyte *buf2;
 523    GLuint i;
 524
 525    buf = malloc(w * h);  /* 1 bpp */
 526    buf2 = malloc(w * h * 3); /* 3 bpp */
 527
 528    _mesa_PushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
 529    _mesa_PixelStorei(GL_PACK_ALIGNMENT, 1);
 530    _mesa_PixelStorei(GL_PACK_INVERT_MESA, GL_TRUE);
 531
 532    _mesa_ReadPixels(0, 0, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, buf);
 533
 534    for (i = 0; i < w * h; i++) {
 535       buf2[i*3+0] = buf[i];
 536       buf2[i*3+1] = (buf[i] & 127) * 2;
 537       buf2[i*3+2] = (buf[i] - 128) * 2;
 538    }
 539
 540    printf("Writing %d x %d stencil buffer to %s\n", w, h, filename);
 541    write_ppm(filename, buf2, w, h, 3, 0, 1, 2, GL_TRUE);
 542
 543    _mesa_PopClientAttrib();
 544
 545    free(buf);
 546    free(buf2);
 547 }
 548
 549
 550 void
 551 _mesa_dump_image(const char *filename, const void *image, GLuint w, GLuint h,
 552                  GLenum format, GLenum type)
 553 {
 554    GLboolean invert = GL_TRUE;
 555
 556    if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
 557       write_ppm(filename, image, w, h, 4, 0, 1, 2, invert);
 558    }
 559    else if (format == GL_BGRA && type == GL_UNSIGNED_BYTE) {
 560       write_ppm(filename, image, w, h, 4, 2, 1, 0, invert);
 561    }
 562    else if (format == GL_LUMINANCE_ALPHA && type == GL_UNSIGNED_BYTE) {
 563       write_ppm(filename, image, w, h, 2, 1, 0, 0, invert);
 564    }
 565    else if (format == GL_RED && type == GL_UNSIGNED_BYTE) {
 566       write_ppm(filename, image, w, h, 1, 0, 0, 0, invert);
 567    }
 568    else if (format == GL_RGBA && type == GL_FLOAT) {
 569       /* convert floats to ubyte */
 570       GLubyte *buf = malloc(w * h * 4 * sizeof(GLubyte));
 571       const GLfloat *f = (const GLfloat *) image;
 572       GLuint i;
 573       for (i = 0; i < w * h * 4; i++) {
 574          UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]);
 575       }
 576       write_ppm(filename, buf, w, h, 4, 0, 1, 2, invert);
 577       free(buf);
 578    }
 579    else if (format == GL_RED && type == GL_FLOAT) {
 580       /* convert floats to ubyte */
 581       GLubyte *buf = malloc(w * h * sizeof(GLubyte));
 582       const GLfloat *f = (const GLfloat *) image;
 583       GLuint i;
 584       for (i = 0; i < w * h; i++) {
 585          UNCLAMPED_FLOAT_TO_UBYTE(buf[i], f[i]);
 586       }
 587       write_ppm(filename, buf, w, h, 1, 0, 0, 0, invert);
 588       free(buf);
 589    }
 590    else {
 591       _mesa_problem(NULL,
 592                  "Unsupported format 0x%x / type 0x%x in _mesa_dump_image()",
 593                  format, type);
 594    }
 595 }
 596
 597
 598 /**
 599  * Quick and dirty function to "print" a texture to stdout.
 600  */
 601 void
 602 _mesa_print_texture(struct gl_context *ctx, struct gl_texture_image *img)
 603 {
 604    const GLint slice = 0;
 605    GLint srcRowStride;
 606    GLuint i, j, c;
 607    GLubyte *data;
 608
 609    ctx->Driver.MapTextureImage(ctx, img, slice,
 610                                0, 0, img->Width, img->Height, GL_MAP_READ_BIT,
 611                                &data, &srcRowStride);
 612
 613    if (!data) {
 614       printf("No texture data\n");
 615    }
 616    else {
 617       /* XXX add more formats or make into a new format utility function */
 618       switch (img->TexFormat) {
 619          case MESA_FORMAT_A_UNORM8:
 620          case MESA_FORMAT_L_UNORM8:
 621          case MESA_FORMAT_I_UNORM8:
 622             c = 1;
 623             break;
 624          case MESA_FORMAT_L8A8_UNORM:
 625          case MESA_FORMAT_A8L8_UNORM:
 626             c = 2;
 627             break;
 628          case MESA_FORMAT_BGR_UNORM8:
 629          case MESA_FORMAT_RGB_UNORM8:
 630             c = 3;
 631             break;
 632          case MESA_FORMAT_A8B8G8R8_UNORM:
 633          case MESA_FORMAT_B8G8R8A8_UNORM:
 634             c = 4;
 635             break;
 636          default:
 637             _mesa_problem(NULL, "error in PrintTexture\n");
 638             return;
 639       }
 640
 641       for (i = 0; i < img->Height; i++) {
 642          for (j = 0; j < img->Width; j++) {
 643             if (c==1)
 644                printf("%02x  ", data[0]);
 645             else if (c==2)
 646                printf("%02x%02x  ", data[0], data[1]);
 647             else if (c==3)
 648                printf("%02x%02x%02x  ", data[0], data[1], data[2]);
 649             else if (c==4)
 650                printf("%02x%02x%02x%02x  ", data[0], data[1], data[2], data[3]);
 651             data += (srcRowStride - img->Width) * c;
 652          }
 653          /* XXX use img->ImageStride here */
 654          printf("\n");
 655
 656       }
 657    }
 658
 659    ctx->Driver.UnmapTextureImage(ctx, img, slice);
 660 }