src/mesa/main/debug.c

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