src/gallium/auxiliary/util/u_debug.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright (c) 2008 VMware, Inc.
   5  * 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
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29
  30 #include "pipe/p_config.h"
  31
  32 #include "pipe/p_compiler.h"
  33 #include "os/os_stream.h"
  34 #include "util/u_debug.h"
  35 #include "pipe/p_format.h"
  36 #include "pipe/p_state.h"
  37 #include "util/u_inlines.h"
  38 #include "util/u_format.h"
  39 #include "util/u_memory.h"
  40 #include "util/u_string.h"
  41 #include "util/u_math.h"
  42 #include "util/u_tile.h"
  43 #include "util/u_prim.h"
  44 #include "util/u_surface.h"
  45
  46 #include <limits.h> /* CHAR_BIT */
  47
  48 void _debug_vprintf(const char *format, va_list ap)
  49 {
  50 #if defined(PIPE_OS_WINDOWS) || defined(PIPE_OS_EMBEDDED)
  51    /* We buffer until we find a newline. */
  52    static char buf[4096] = {'\0'};
  53    size_t len = strlen(buf);
  54    int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap);
  55    if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) {
  56       os_log_message(buf);
  57       buf[0] = '\0';
  58    }
  59 #else
  60    /* Just print as-is to stderr */
  61    vfprintf(stderr, format, ap);
  62 #endif
  63 }
  64
  65
  66 #ifdef DEBUG
  67 void debug_print_blob( const char *name,
  68                        const void *blob,
  69                        unsigned size )
  70 {
  71    const unsigned *ublob = (const unsigned *)blob;
  72    unsigned i;
  73
  74    debug_printf("%s (%d dwords%s)\n", name, size/4,
  75                 size%4 ? "... plus a few bytes" : "");
  76
  77    for (i = 0; i < size/4; i++) {
  78       debug_printf("%d:\t%08x\n", i, ublob[i]);
  79    }
  80 }
  81 #endif
  82
  83
  84 static boolean
  85 debug_get_option_should_print(void)
  86 {
  87    static boolean first = TRUE;
  88    static boolean value = FALSE;
  89
  90    if (!first)
  91       return value;
  92
  93    /* Oh hey this will call into this function,
  94     * but its cool since we set first to false
  95     */
  96    first = FALSE;
  97    value = debug_get_bool_option("GALLIUM_PRINT_OPTIONS", FALSE);
  98    /* XXX should we print this option? Currently it wont */
  99    return value;
 100 }
 101
 102 const char *
 103 debug_get_option(const char *name, const char *dfault)
 104 {
 105    const char *result;
 106
 107    result = os_get_option(name);
 108    if(!result)
 109       result = dfault;
 110
 111    if (debug_get_option_should_print())
 112       debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)");
 113
 114    return result;
 115 }
 116
 117 boolean
 118 debug_get_bool_option(const char *name, boolean dfault)
 119 {
 120    const char *str = os_get_option(name);
 121    boolean result;
 122
 123    if(str == NULL)
 124       result = dfault;
 125    else if(!util_strcmp(str, "n"))
 126       result = FALSE;
 127    else if(!util_strcmp(str, "no"))
 128       result = FALSE;
 129    else if(!util_strcmp(str, "0"))
 130       result = FALSE;
 131    else if(!util_strcmp(str, "f"))
 132       result = FALSE;
 133    else if(!util_strcmp(str, "F"))
 134       result = FALSE;
 135    else if(!util_strcmp(str, "false"))
 136       result = FALSE;
 137    else if(!util_strcmp(str, "FALSE"))
 138       result = FALSE;
 139    else
 140       result = TRUE;
 141
 142    if (debug_get_option_should_print())
 143       debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE");
 144
 145    return result;
 146 }
 147
 148
 149 long
 150 debug_get_num_option(const char *name, long dfault)
 151 {
 152    long result;
 153    const char *str;
 154
 155    str = os_get_option(name);
 156    if(!str)
 157       result = dfault;
 158    else {
 159       long sign;
 160       char c;
 161       c = *str++;
 162       if(c == '-') {
 163          sign = -1;
 164          c = *str++;
 165       }
 166       else {
 167          sign = 1;
 168       }
 169       result = 0;
 170       while('0' <= c && c <= '9') {
 171          result = result*10 + (c - '0');
 172          c = *str++;
 173       }
 174       result *= sign;
 175    }
 176
 177    if (debug_get_option_should_print())
 178       debug_printf("%s: %s = %li\n", __FUNCTION__, name, result);
 179
 180    return result;
 181 }
 182
 183 static boolean str_has_option(const char *str, const char *name)
 184 {
 185    const char *substr;
 186
 187    /* OPTION=all */
 188    if (!util_strcmp(str, "all")) {
 189       return TRUE;
 190    }
 191
 192    /* OPTION=name */
 193    if (!util_strcmp(str, name)) {
 194       return TRUE;
 195    }
 196
 197    substr = util_strstr(str, name);
 198
 199    if (substr) {
 200       unsigned name_len = strlen(name);
 201
 202       /* OPTION=name,... */
 203       if (substr == str && substr[name_len] == ',') {
 204          return TRUE;
 205       }
 206
 207       /* OPTION=...,name */
 208       if (substr+name_len == str+strlen(str) && substr[-1] == ',') {
 209          return TRUE;
 210       }
 211
 212       /* OPTION=...,name,... */
 213       if (substr[-1] == ',' && substr[name_len] == ',') {
 214          return TRUE;
 215       }
 216    }
 217
 218    return FALSE;
 219 }
 220
 221 unsigned long
 222 debug_get_flags_option(const char *name,
 223                        const struct debug_named_value *flags,
 224                        unsigned long dfault)
 225 {
 226    unsigned long result;
 227    const char *str;
 228    const struct debug_named_value *orig = flags;
 229    int namealign = 0;
 230
 231    str = os_get_option(name);
 232    if(!str)
 233       result = dfault;
 234    else if (!util_strcmp(str, "help")) {
 235       result = dfault;
 236       _debug_printf("%s: help for %s:\n", __FUNCTION__, name);
 237       for (; flags->name; ++flags)
 238          namealign = MAX2(namealign, strlen(flags->name));
 239       for (flags = orig; flags->name; ++flags)
 240          _debug_printf("| %*s [0x%0*lx]%s%s\n", namealign, flags->name,
 241                       (int)sizeof(unsigned long)*CHAR_BIT/4, flags->value,
 242                       flags->desc ? " " : "", flags->desc ? flags->desc : "");
 243    }
 244    else {
 245       result = 0;
 246       while( flags->name ) {
 247          if (str_has_option(str, flags->name))
 248             result |= flags->value;
 249          ++flags;
 250       }
 251    }
 252
 253    if (debug_get_option_should_print()) {
 254       if (str) {
 255          debug_printf("%s: %s = 0x%lx (%s)\n", __FUNCTION__, name, result, str);
 256       } else {
 257          debug_printf("%s: %s = 0x%lx\n", __FUNCTION__, name, result);
 258       }
 259    }
 260
 261    return result;
 262 }
 263
 264
 265 void _debug_assert_fail(const char *expr,
 266                         const char *file,
 267                         unsigned line,
 268                         const char *function)
 269 {
 270    _debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr);
 271 #if defined(PIPE_OS_WINDOWS) && !defined(PIPE_SUBSYSTEM_WINDOWS_USER)
 272    if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", FALSE))
 273 #else
 274    if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", TRUE))
 275 #endif
 276       os_abort();
 277    else
 278       _debug_printf("continuing...\n");
 279 }
 280
 281
 282 const char *
 283 debug_dump_enum(const struct debug_named_value *names,
 284                 unsigned long value)
 285 {
 286    static char rest[64];
 287
 288    while(names->name) {
 289       if(names->value == value)
 290          return names->name;
 291       ++names;
 292    }
 293
 294    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 295    return rest;
 296 }
 297
 298
 299 const char *
 300 debug_dump_enum_noprefix(const struct debug_named_value *names,
 301                          const char *prefix,
 302                          unsigned long value)
 303 {
 304    static char rest[64];
 305
 306    while(names->name) {
 307       if(names->value == value) {
 308          const char *name = names->name;
 309          while (*name == *prefix) {
 310             name++;
 311             prefix++;
 312          }
 313          return name;
 314       }
 315       ++names;
 316    }
 317
 318
 319
 320    util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 321    return rest;
 322 }
 323
 324
 325 const char *
 326 debug_dump_flags(const struct debug_named_value *names,
 327                  unsigned long value)
 328 {
 329    static char output[4096];
 330    static char rest[256];
 331    int first = 1;
 332
 333    output[0] = '\0';
 334
 335    while(names->name) {
 336       if((names->value & value) == names->value) {
 337          if (!first)
 338             util_strncat(output, "|", sizeof(output));
 339          else
 340             first = 0;
 341          util_strncat(output, names->name, sizeof(output) - 1);
 342          output[sizeof(output) - 1] = '\0';
 343          value &= ~names->value;
 344       }
 345       ++names;
 346    }
 347
 348    if (value) {
 349       if (!first)
 350          util_strncat(output, "|", sizeof(output));
 351       else
 352          first = 0;
 353
 354       util_snprintf(rest, sizeof(rest), "0x%08lx", value);
 355       util_strncat(output, rest, sizeof(output) - 1);
 356       output[sizeof(output) - 1] = '\0';
 357    }
 358
 359    if(first)
 360       return "0";
 361
 362    return output;
 363 }
 364
 365
 366 #ifdef DEBUG
 367 void debug_print_format(const char *msg, unsigned fmt )
 368 {
 369    debug_printf("%s: %s\n", msg, util_format_name(fmt));
 370 }
 371 #endif
 372
 373
 374
 375 static const struct debug_named_value pipe_prim_names[] = {
 376 #ifdef DEBUG
 377    DEBUG_NAMED_VALUE(PIPE_PRIM_POINTS),
 378    DEBUG_NAMED_VALUE(PIPE_PRIM_LINES),
 379    DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_LOOP),
 380    DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP),
 381    DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES),
 382    DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP),
 383    DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_FAN),
 384    DEBUG_NAMED_VALUE(PIPE_PRIM_QUADS),
 385    DEBUG_NAMED_VALUE(PIPE_PRIM_QUAD_STRIP),
 386    DEBUG_NAMED_VALUE(PIPE_PRIM_POLYGON),
 387 #endif
 388    DEBUG_NAMED_VALUE_END
 389 };
 390
 391
 392 const char *u_prim_name( unsigned prim )
 393 {
 394    return debug_dump_enum(pipe_prim_names, prim);
 395 }
 396
 397
 398
 399 #ifdef DEBUG
 400 int fl_indent = 0;
 401 const char* fl_function[1024];
 402
 403 int debug_funclog_enter(const char* f, const int line, const char* file)
 404 {
 405    int i;
 406
 407    for (i = 0; i < fl_indent; i++)
 408       debug_printf("  ");
 409    debug_printf("%s\n", f);
 410
 411    assert(fl_indent < 1023);
 412    fl_function[fl_indent++] = f;
 413
 414    return 0;
 415 }
 416
 417 void debug_funclog_exit(const char* f, const int line, const char* file)
 418 {
 419    --fl_indent;
 420    assert(fl_indent >= 0);
 421    assert(fl_function[fl_indent] == f);
 422 }
 423
 424 void debug_funclog_enter_exit(const char* f, const int line, const char* file)
 425 {
 426    int i;
 427    for (i = 0; i < fl_indent; i++)
 428       debug_printf("  ");
 429    debug_printf("%s\n", f);
 430 }
 431 #endif
 432
 433
 434
 435 #ifdef DEBUG
 436 /**
 437  * Dump an image to a .raw or .ppm file (depends on OS).
 438  * \param format  PIPE_FORMAT_x
 439  * \param cpp  bytes per pixel
 440  * \param width  width in pixels
 441  * \param height height in pixels
 442  * \param stride  row stride in bytes
 443  */
 444 void debug_dump_image(const char *prefix,
 445                       unsigned format, unsigned cpp,
 446                       unsigned width, unsigned height,
 447                       unsigned stride,
 448                       const void *data)
 449 {
 450 #ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
 451    static unsigned no = 0;
 452    char filename[256];
 453    WCHAR wfilename[sizeof(filename)];
 454    ULONG_PTR iFile = 0;
 455    struct {
 456       unsigned format;
 457       unsigned cpp;
 458       unsigned width;
 459       unsigned height;
 460    } header;
 461    unsigned char *pMap = NULL;
 462    unsigned i;
 463
 464    util_snprintf(filename, sizeof(filename), "\\??\\c:\\%03u%s.raw", ++no, prefix);
 465    for(i = 0; i < sizeof(filename); ++i)
 466       wfilename[i] = (WCHAR)filename[i];
 467
 468    pMap = (unsigned char *)EngMapFile(wfilename, sizeof(header) + height*width*cpp, &iFile);
 469    if(!pMap)
 470       return;
 471
 472    header.format = format;
 473    header.cpp = cpp;
 474    header.width = width;
 475    header.height = height;
 476    memcpy(pMap, &header, sizeof(header));
 477    pMap += sizeof(header);
 478
 479    for(i = 0; i < height; ++i) {
 480       memcpy(pMap, (unsigned char *)data + stride*i, cpp*width);
 481       pMap += cpp*width;
 482    }
 483
 484    EngUnmapFile(iFile);
 485 #elif defined(PIPE_OS_UNIX)
 486    /* write a ppm file */
 487    char filename[256];
 488    FILE *f;
 489
 490    util_snprintf(filename, sizeof(filename), "%s.ppm", prefix);
 491
 492    f = fopen(filename, "w");
 493    if (f) {
 494       int i, x, y;
 495       int r, g, b;
 496       const uint8_t *ptr = (uint8_t *) data;
 497
 498       /* XXX this is a hack */
 499       switch (format) {
 500       case PIPE_FORMAT_B8G8R8A8_UNORM:
 501          r = 2;
 502          g = 1;
 503          b = 0;
 504          break;
 505       default:
 506          r = 0;
 507          g = 1;
 508          b = 1;
 509       }
 510
 511       fprintf(f, "P6\n");
 512       fprintf(f, "# ppm-file created by osdemo.c\n");
 513       fprintf(f, "%i %i\n", width, height);
 514       fprintf(f, "255\n");
 515       fclose(f);
 516
 517       f = fopen(filename, "ab");  /* reopen in binary append mode */
 518       for (y = 0; y < height; y++) {
 519          for (x = 0; x < width; x++) {
 520             i = y * stride + x * cpp;
 521             fputc(ptr[i + r], f); /* write red */
 522             fputc(ptr[i + g], f); /* write green */
 523             fputc(ptr[i + b], f); /* write blue */
 524          }
 525       }
 526       fclose(f);
 527    }
 528    else {
 529       fprintf(stderr, "Can't open %s for writing\n", filename);
 530    }
 531 #endif
 532 }
 533
 534 /* FIXME: dump resources, not surfaces... */
 535 void debug_dump_surface(struct pipe_context *pipe,
 536                         const char *prefix,
 537                         struct pipe_surface *surface)
 538 {
 539    struct pipe_resource *texture;
 540    struct pipe_transfer *transfer;
 541    void *data;
 542
 543    if (!surface)
 544       return;
 545
 546    /* XXX: this doesn't necessarily work, as the driver may be using
 547     * temporary storage for the surface which hasn't been propagated
 548     * back into the texture.  Need to nail down the semantics of views
 549     * and transfers a bit better before we can say if extra work needs
 550     * to be done here:
 551     */
 552    texture = surface->texture;
 553
 554    transfer = pipe_get_transfer(pipe, texture, surface->u.tex.level,
 555                                 surface->u.tex.first_layer,
 556                                 PIPE_TRANSFER_READ,
 557                                 0, 0, surface->width, surface->height);
 558
 559    data = pipe->transfer_map(pipe, transfer);
 560    if(!data)
 561       goto error;
 562
 563    debug_dump_image(prefix,
 564                     texture->format,
 565                     util_format_get_blocksize(texture->format),
 566                     util_format_get_nblocksx(texture->format, surface->width),
 567                     util_format_get_nblocksy(texture->format, surface->height),
 568                     transfer->stride,
 569                     data);
 570
 571    pipe->transfer_unmap(pipe, transfer);
 572 error:
 573    pipe->transfer_destroy(pipe, transfer);
 574 }
 575
 576
 577 void debug_dump_texture(struct pipe_context *pipe,
 578                         const char *prefix,
 579                         struct pipe_resource *texture)
 580 {
 581    struct pipe_surface *surface, surf_tmpl;
 582
 583    if (!texture)
 584       return;
 585
 586    /* XXX for now, just dump image for layer=0, level=0 */
 587    memset(&surf_tmpl, 0, sizeof(surf_tmpl));
 588    u_surface_default_template(&surf_tmpl, texture, 0 /* no bind flag - not a surface */);
 589    surface = pipe->create_surface(pipe, texture, &surf_tmpl);
 590    if (surface) {
 591       debug_dump_surface(pipe, prefix, surface);
 592       pipe->surface_destroy(pipe, surface);
 593    }
 594 }
 595
 596
 597 #pragma pack(push,2)
 598 struct bmp_file_header {
 599    uint16_t bfType;
 600    uint32_t bfSize;
 601    uint16_t bfReserved1;
 602    uint16_t bfReserved2;
 603    uint32_t bfOffBits;
 604 };
 605 #pragma pack(pop)
 606
 607 struct bmp_info_header {
 608    uint32_t biSize;
 609    int32_t biWidth;
 610    int32_t biHeight;
 611    uint16_t biPlanes;
 612    uint16_t biBitCount;
 613    uint32_t biCompression;
 614    uint32_t biSizeImage;
 615    int32_t biXPelsPerMeter;
 616    int32_t biYPelsPerMeter;
 617    uint32_t biClrUsed;
 618    uint32_t biClrImportant;
 619 };
 620
 621 struct bmp_rgb_quad {
 622    uint8_t rgbBlue;
 623    uint8_t rgbGreen;
 624    uint8_t rgbRed;
 625    uint8_t rgbAlpha;
 626 };
 627
 628 void
 629 debug_dump_surface_bmp(struct pipe_context *pipe,
 630                        const char *filename,
 631                        struct pipe_surface *surface)
 632 {
 633 #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
 634    struct pipe_transfer *transfer;
 635    struct pipe_resource *texture = surface->texture;
 636
 637    transfer = pipe_get_transfer(pipe, texture, surface->u.tex.level,
 638                                 surface->u.tex.first_layer, PIPE_TRANSFER_READ,
 639                                 0, 0, surface->width, surface->height);
 640
 641    debug_dump_transfer_bmp(pipe, filename, transfer);
 642
 643    pipe->transfer_destroy(pipe, transfer);
 644 #endif
 645 }
 646
 647 void
 648 debug_dump_transfer_bmp(struct pipe_context *pipe,
 649                         const char *filename,
 650                         struct pipe_transfer *transfer)
 651 {
 652 #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
 653    float *rgba;
 654
 655    if (!transfer)
 656       goto error1;
 657
 658    rgba = MALLOC(transfer->box.width *
 659                  transfer->box.height *
 660                  transfer->box.depth *
 661                  4*sizeof(float));
 662    if(!rgba)
 663       goto error1;
 664
 665    pipe_get_tile_rgba(pipe, transfer, 0, 0,
 666                       transfer->box.width, transfer->box.height,
 667                       rgba);
 668
 669    debug_dump_float_rgba_bmp(filename,
 670                              transfer->box.width, transfer->box.height,
 671                              rgba, transfer->box.width);
 672
 673    FREE(rgba);
 674 error1:
 675    ;
 676 #endif
 677 }
 678
 679 void
 680 debug_dump_float_rgba_bmp(const char *filename,
 681                           unsigned width, unsigned height,
 682                           float *rgba, unsigned stride)
 683 {
 684 #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
 685    struct os_stream *stream;
 686    struct bmp_file_header bmfh;
 687    struct bmp_info_header bmih;
 688    unsigned x, y;
 689
 690    if(!rgba)
 691       goto error1;
 692
 693    bmfh.bfType = 0x4d42;
 694    bmfh.bfSize = 14 + 40 + height*width*4;
 695    bmfh.bfReserved1 = 0;
 696    bmfh.bfReserved2 = 0;
 697    bmfh.bfOffBits = 14 + 40;
 698
 699    bmih.biSize = 40;
 700    bmih.biWidth = width;
 701    bmih.biHeight = height;
 702    bmih.biPlanes = 1;
 703    bmih.biBitCount = 32;
 704    bmih.biCompression = 0;
 705    bmih.biSizeImage = height*width*4;
 706    bmih.biXPelsPerMeter = 0;
 707    bmih.biYPelsPerMeter = 0;
 708    bmih.biClrUsed = 0;
 709    bmih.biClrImportant = 0;
 710
 711    stream = os_file_stream_create(filename);
 712    if(!stream)
 713       goto error1;
 714
 715    os_stream_write(stream, &bmfh, 14);
 716    os_stream_write(stream, &bmih, 40);
 717
 718    y = height;
 719    while(y--) {
 720       float *ptr = rgba + (stride * y * 4);
 721       for(x = 0; x < width; ++x)
 722       {
 723          struct bmp_rgb_quad pixel;
 724          pixel.rgbRed   = float_to_ubyte(ptr[x*4 + 0]);
 725          pixel.rgbGreen = float_to_ubyte(ptr[x*4 + 1]);
 726          pixel.rgbBlue  = float_to_ubyte(ptr[x*4 + 2]);
 727          pixel.rgbAlpha = 255;
 728          os_stream_write(stream, &pixel, 4);
 729       }
 730    }
 731
 732    os_stream_close(stream);
 733 error1:
 734    ;
 735 #endif
 736 }
 737
 738 #endif