/************************************************************************** * * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. * Copyright (c) 2008 VMware, Inc. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * **************************************************************************/ #include "pipe/p_config.h" #include "pipe/p_compiler.h" #include "os/os_stream.h" #include "util/u_debug.h" #include "pipe/p_format.h" #include "pipe/p_state.h" #include "util/u_inlines.h" #include "util/u_format.h" #include "util/u_memory.h" #include "util/u_string.h" #include "util/u_math.h" #include "util/u_tile.h" #include "util/u_prim.h" #include "util/u_surface.h" #include /* CHAR_BIT */ #include /* isalnum */ void _debug_vprintf(const char *format, va_list ap) { #if defined(PIPE_OS_WINDOWS) || defined(PIPE_OS_EMBEDDED) /* We buffer until we find a newline. */ static char buf[4096] = {'\0'}; size_t len = strlen(buf); int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap); if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) { os_log_message(buf); buf[0] = '\0'; } #else /* Just print as-is to stderr */ vfprintf(stderr, format, ap); #endif } #ifdef DEBUG void debug_print_blob( const char *name, const void *blob, unsigned size ) { const unsigned *ublob = (const unsigned *)blob; unsigned i; debug_printf("%s (%d dwords%s)\n", name, size/4, size%4 ? "... plus a few bytes" : ""); for (i = 0; i < size/4; i++) { debug_printf("%d:\t%08x\n", i, ublob[i]); } } #endif static boolean debug_get_option_should_print(void) { static boolean first = TRUE; static boolean value = FALSE; if (!first) return value; /* Oh hey this will call into this function, * but its cool since we set first to false */ first = FALSE; value = debug_get_bool_option("GALLIUM_PRINT_OPTIONS", FALSE); /* XXX should we print this option? Currently it wont */ return value; } const char * debug_get_option(const char *name, const char *dfault) { const char *result; result = os_get_option(name); if(!result) result = dfault; if (debug_get_option_should_print()) debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)"); return result; } boolean debug_get_bool_option(const char *name, boolean dfault) { const char *str = os_get_option(name); boolean result; if(str == NULL) result = dfault; else if(!util_strcmp(str, "n")) result = FALSE; else if(!util_strcmp(str, "no")) result = FALSE; else if(!util_strcmp(str, "0")) result = FALSE; else if(!util_strcmp(str, "f")) result = FALSE; else if(!util_strcmp(str, "F")) result = FALSE; else if(!util_strcmp(str, "false")) result = FALSE; else if(!util_strcmp(str, "FALSE")) result = FALSE; else result = TRUE; if (debug_get_option_should_print()) debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE"); return result; } long debug_get_num_option(const char *name, long dfault) { long result; const char *str; str = os_get_option(name); if(!str) result = dfault; else { long sign; char c; c = *str++; if(c == '-') { sign = -1; c = *str++; } else { sign = 1; } result = 0; while('0' <= c && c <= '9') { result = result*10 + (c - '0'); c = *str++; } result *= sign; } if (debug_get_option_should_print()) debug_printf("%s: %s = %li\n", __FUNCTION__, name, result); return result; } static boolean str_has_option(const char *str, const char *name) { /* Empty string. */ if (!*str) { return FALSE; } /* OPTION=all */ if (!util_strcmp(str, "all")) { return TRUE; } /* Find 'name' in 'str' surrounded by non-alphanumeric characters. */ { const char *start = str; unsigned name_len = strlen(name); /* 'start' is the beginning of the currently-parsed word, * we increment 'str' each iteration. * if we find either the end of string or a non-alphanumeric character, * we compare 'start' up to 'str-1' with 'name'. */ while (1) { if (!*str || !isalnum(*str)) { if (str-start == name_len && !memcmp(start, name, name_len)) { return TRUE; } if (!*str) { return FALSE; } start = str+1; } str++; } } return FALSE; } unsigned long debug_get_flags_option(const char *name, const struct debug_named_value *flags, unsigned long dfault) { unsigned long result; const char *str; const struct debug_named_value *orig = flags; int namealign = 0; str = os_get_option(name); if(!str) result = dfault; else if (!util_strcmp(str, "help")) { result = dfault; _debug_printf("%s: help for %s:\n", __FUNCTION__, name); for (; flags->name; ++flags) namealign = MAX2(namealign, strlen(flags->name)); for (flags = orig; flags->name; ++flags) _debug_printf("| %*s [0x%0*lx]%s%s\n", namealign, flags->name, (int)sizeof(unsigned long)*CHAR_BIT/4, flags->value, flags->desc ? " " : "", flags->desc ? flags->desc : ""); } else { result = 0; while( flags->name ) { if (str_has_option(str, flags->name)) result |= flags->value; ++flags; } } if (debug_get_option_should_print()) { if (str) { debug_printf("%s: %s = 0x%lx (%s)\n", __FUNCTION__, name, result, str); } else { debug_printf("%s: %s = 0x%lx\n", __FUNCTION__, name, result); } } return result; } void _debug_assert_fail(const char *expr, const char *file, unsigned line, const char *function) { _debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr); #if defined(PIPE_OS_WINDOWS) && !defined(PIPE_SUBSYSTEM_WINDOWS_USER) if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", FALSE)) #else if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", TRUE)) #endif os_abort(); else _debug_printf("continuing...\n"); } const char * debug_dump_enum(const struct debug_named_value *names, unsigned long value) { static char rest[64]; while(names->name) { if(names->value == value) return names->name; ++names; } util_snprintf(rest, sizeof(rest), "0x%08lx", value); return rest; } const char * debug_dump_enum_noprefix(const struct debug_named_value *names, const char *prefix, unsigned long value) { static char rest[64]; while(names->name) { if(names->value == value) { const char *name = names->name; while (*name == *prefix) { name++; prefix++; } return name; } ++names; } util_snprintf(rest, sizeof(rest), "0x%08lx", value); return rest; } const char * debug_dump_flags(const struct debug_named_value *names, unsigned long value) { static char output[4096]; static char rest[256]; int first = 1; output[0] = '\0'; while(names->name) { if((names->value & value) == names->value) { if (!first) util_strncat(output, "|", sizeof(output)); else first = 0; util_strncat(output, names->name, sizeof(output) - 1); output[sizeof(output) - 1] = '\0'; value &= ~names->value; } ++names; } if (value) { if (!first) util_strncat(output, "|", sizeof(output)); else first = 0; util_snprintf(rest, sizeof(rest), "0x%08lx", value); util_strncat(output, rest, sizeof(output) - 1); output[sizeof(output) - 1] = '\0'; } if(first) return "0"; return output; } #ifdef DEBUG void debug_print_format(const char *msg, unsigned fmt ) { debug_printf("%s: %s\n", msg, util_format_name(fmt)); } #endif static const struct debug_named_value pipe_prim_names[] = { #ifdef DEBUG DEBUG_NAMED_VALUE(PIPE_PRIM_POINTS), DEBUG_NAMED_VALUE(PIPE_PRIM_LINES), DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_LOOP), DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP), DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES), DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP), DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_FAN), DEBUG_NAMED_VALUE(PIPE_PRIM_QUADS), DEBUG_NAMED_VALUE(PIPE_PRIM_QUAD_STRIP), DEBUG_NAMED_VALUE(PIPE_PRIM_POLYGON), #endif DEBUG_NAMED_VALUE_END }; const char *u_prim_name( unsigned prim ) { return debug_dump_enum(pipe_prim_names, prim); } #ifdef DEBUG int fl_indent = 0; const char* fl_function[1024]; int debug_funclog_enter(const char* f, const int line, const char* file) { int i; for (i = 0; i < fl_indent; i++) debug_printf(" "); debug_printf("%s\n", f); assert(fl_indent < 1023); fl_function[fl_indent++] = f; return 0; } void debug_funclog_exit(const char* f, const int line, const char* file) { --fl_indent; assert(fl_indent >= 0); assert(fl_function[fl_indent] == f); } void debug_funclog_enter_exit(const char* f, const int line, const char* file) { int i; for (i = 0; i < fl_indent; i++) debug_printf(" "); debug_printf("%s\n", f); } #endif #ifdef DEBUG /** * Dump an image to a .raw or .ppm file (depends on OS). * \param format PIPE_FORMAT_x * \param cpp bytes per pixel * \param width width in pixels * \param height height in pixels * \param stride row stride in bytes */ void debug_dump_image(const char *prefix, unsigned format, unsigned cpp, unsigned width, unsigned height, unsigned stride, const void *data) { #ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY static unsigned no = 0; char filename[256]; WCHAR wfilename[sizeof(filename)]; ULONG_PTR iFile = 0; struct { unsigned format; unsigned cpp; unsigned width; unsigned height; } header; unsigned char *pMap = NULL; unsigned i; util_snprintf(filename, sizeof(filename), "\\??\\c:\\%03u%s.raw", ++no, prefix); for(i = 0; i < sizeof(filename); ++i) wfilename[i] = (WCHAR)filename[i]; pMap = (unsigned char *)EngMapFile(wfilename, sizeof(header) + height*width*cpp, &iFile); if(!pMap) return; header.format = format; header.cpp = cpp; header.width = width; header.height = height; memcpy(pMap, &header, sizeof(header)); pMap += sizeof(header); for(i = 0; i < height; ++i) { memcpy(pMap, (unsigned char *)data + stride*i, cpp*width); pMap += cpp*width; } EngUnmapFile(iFile); #elif defined(PIPE_OS_UNIX) /* write a ppm file */ char filename[256]; FILE *f; util_snprintf(filename, sizeof(filename), "%s.ppm", prefix); f = fopen(filename, "w"); if (f) { int i, x, y; int r, g, b; const uint8_t *ptr = (uint8_t *) data; /* XXX this is a hack */ switch (format) { case PIPE_FORMAT_B8G8R8A8_UNORM: r = 2; g = 1; b = 0; break; default: r = 0; g = 1; b = 1; } fprintf(f, "P6\n"); fprintf(f, "# ppm-file created by osdemo.c\n"); fprintf(f, "%i %i\n", width, height); fprintf(f, "255\n"); fclose(f); f = fopen(filename, "ab"); /* reopen in binary append mode */ for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { i = y * stride + x * cpp; fputc(ptr[i + r], f); /* write red */ fputc(ptr[i + g], f); /* write green */ fputc(ptr[i + b], f); /* write blue */ } } fclose(f); } else { fprintf(stderr, "Can't open %s for writing\n", filename); } #endif } /* FIXME: dump resources, not surfaces... */ void debug_dump_surface(struct pipe_context *pipe, const char *prefix, struct pipe_surface *surface) { struct pipe_resource *texture; struct pipe_transfer *transfer; void *data; if (!surface) return; /* XXX: this doesn't necessarily work, as the driver may be using * temporary storage for the surface which hasn't been propagated * back into the texture. Need to nail down the semantics of views * and transfers a bit better before we can say if extra work needs * to be done here: */ texture = surface->texture; transfer = pipe_get_transfer(pipe, texture, surface->u.tex.level, surface->u.tex.first_layer, PIPE_TRANSFER_READ, 0, 0, surface->width, surface->height); data = pipe->transfer_map(pipe, transfer); if(!data) goto error; debug_dump_image(prefix, texture->format, util_format_get_blocksize(texture->format), util_format_get_nblocksx(texture->format, surface->width), util_format_get_nblocksy(texture->format, surface->height), transfer->stride, data); pipe->transfer_unmap(pipe, transfer); error: pipe->transfer_destroy(pipe, transfer); } void debug_dump_texture(struct pipe_context *pipe, const char *prefix, struct pipe_resource *texture) { struct pipe_surface *surface, surf_tmpl; if (!texture) return; /* XXX for now, just dump image for layer=0, level=0 */ memset(&surf_tmpl, 0, sizeof(surf_tmpl)); u_surface_default_template(&surf_tmpl, texture, 0 /* no bind flag - not a surface */); surface = pipe->create_surface(pipe, texture, &surf_tmpl); if (surface) { debug_dump_surface(pipe, prefix, surface); pipe->surface_destroy(pipe, surface); } } #pragma pack(push,2) struct bmp_file_header { uint16_t bfType; uint32_t bfSize; uint16_t bfReserved1; uint16_t bfReserved2; uint32_t bfOffBits; }; #pragma pack(pop) struct bmp_info_header { uint32_t biSize; int32_t biWidth; int32_t biHeight; uint16_t biPlanes; uint16_t biBitCount; uint32_t biCompression; uint32_t biSizeImage; int32_t biXPelsPerMeter; int32_t biYPelsPerMeter; uint32_t biClrUsed; uint32_t biClrImportant; }; struct bmp_rgb_quad { uint8_t rgbBlue; uint8_t rgbGreen; uint8_t rgbRed; uint8_t rgbAlpha; }; void debug_dump_surface_bmp(struct pipe_context *pipe, const char *filename, struct pipe_surface *surface) { #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT struct pipe_transfer *transfer; struct pipe_resource *texture = surface->texture; transfer = pipe_get_transfer(pipe, texture, surface->u.tex.level, surface->u.tex.first_layer, PIPE_TRANSFER_READ, 0, 0, surface->width, surface->height); debug_dump_transfer_bmp(pipe, filename, transfer); pipe->transfer_destroy(pipe, transfer); #endif } void debug_dump_transfer_bmp(struct pipe_context *pipe, const char *filename, struct pipe_transfer *transfer) { #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT float *rgba; if (!transfer) goto error1; rgba = MALLOC(transfer->box.width * transfer->box.height * transfer->box.depth * 4*sizeof(float)); if(!rgba) goto error1; pipe_get_tile_rgba(pipe, transfer, 0, 0, transfer->box.width, transfer->box.height, rgba); debug_dump_float_rgba_bmp(filename, transfer->box.width, transfer->box.height, rgba, transfer->box.width); FREE(rgba); error1: ; #endif } void debug_dump_float_rgba_bmp(const char *filename, unsigned width, unsigned height, float *rgba, unsigned stride) { #ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT struct os_stream *stream; struct bmp_file_header bmfh; struct bmp_info_header bmih; unsigned x, y; if(!rgba) goto error1; bmfh.bfType = 0x4d42; bmfh.bfSize = 14 + 40 + height*width*4; bmfh.bfReserved1 = 0; bmfh.bfReserved2 = 0; bmfh.bfOffBits = 14 + 40; bmih.biSize = 40; bmih.biWidth = width; bmih.biHeight = height; bmih.biPlanes = 1; bmih.biBitCount = 32; bmih.biCompression = 0; bmih.biSizeImage = height*width*4; bmih.biXPelsPerMeter = 0; bmih.biYPelsPerMeter = 0; bmih.biClrUsed = 0; bmih.biClrImportant = 0; stream = os_file_stream_create(filename); if(!stream) goto error1; os_stream_write(stream, &bmfh, 14); os_stream_write(stream, &bmih, 40); y = height; while(y--) { float *ptr = rgba + (stride * y * 4); for(x = 0; x < width; ++x) { struct bmp_rgb_quad pixel; pixel.rgbRed = float_to_ubyte(ptr[x*4 + 0]); pixel.rgbGreen = float_to_ubyte(ptr[x*4 + 1]); pixel.rgbBlue = float_to_ubyte(ptr[x*4 + 2]); pixel.rgbAlpha = 255; os_stream_write(stream, &pixel, 4); } } os_stream_close(stream); error1: ; #endif } #endif