/**************************************************************************
*
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
* Copyright (c) 2008 VMware, Inc.
* All Rights Reserved.
*
* 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
+ * IN NO EVENT SHALL VMWARE 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_string.h"
#include "util/u_math.h"
#include "util/u_tile.h"
-#include "util/u_prim.h"
+#include "util/u_prim.h"
+#include "util/u_surface.h"
+#include <inttypes.h>
+
+#include <stdio.h>
+#include <limits.h> /* CHAR_BIT */
+#include <ctype.h> /* isalnum */
+
+#ifdef _WIN32
+#include <windows.h>
+#include <stdlib.h>
+#endif
void _debug_vprintf(const char *format, va_list ap)
{
- /* We buffer until we find a newline. */
static char buf[4096] = {'\0'};
+#if defined(PIPE_OS_WINDOWS) || defined(PIPE_SUBSYSTEM_EMBEDDED)
+ /* We buffer until we find a newline. */
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
+ util_vsnprintf(buf, sizeof(buf), format, ap);
+ os_log_message(buf);
+#endif
+}
+
+void
+_pipe_debug_message(
+ struct pipe_debug_callback *cb,
+ unsigned *id,
+ enum pipe_debug_type type,
+ const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ if (cb && cb->debug_message)
+ cb->debug_message(cb->data, id, type, fmt, args);
+ va_end(args);
+}
+
+
+void
+debug_disable_error_message_boxes(void)
+{
+#ifdef _WIN32
+ /* When Windows' error message boxes are disabled for this process (as is
+ * typically the case when running tests in an automated fashion) we disable
+ * CRT message boxes too.
+ */
+ UINT uMode = SetErrorMode(0);
+ SetErrorMode(uMode);
+ if (uMode & SEM_FAILCRITICALERRORS) {
+ /* Disable assertion failure message box.
+ * http://msdn.microsoft.com/en-us/library/sas1dkb2.aspx
+ */
+ _set_error_mode(_OUT_TO_STDERR);
+#ifdef _MSC_VER
+ /* Disable abort message box.
+ * http://msdn.microsoft.com/en-us/library/e631wekh.aspx
+ */
+ _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+#endif
+ }
+#endif /* _WIN32 */
}
#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)
+ if (!result)
result = dfault;
-
- debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)");
+
+ if (debug_get_option_should_print())
+ debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)");
return result;
}
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;
- debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE");
+ if (debug_get_option_should_print())
+ debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE");
return result;
}
}
result *= sign;
}
-
- debug_printf("%s: %s = %li\n", __FUNCTION__, name, result);
+
+ 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) || *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
+uint64_t
debug_get_flags_option(const char *name,
const struct debug_named_value *flags,
- unsigned long dfault)
+ uint64_t dfault)
{
- unsigned long result;
+ uint64_t result;
const char *str;
+ const struct debug_named_value *orig = flags;
+ unsigned namealign = 0;
str = os_get_option(name);
if(!str)
result = dfault;
else if (!util_strcmp(str, "help")) {
result = dfault;
- while (flags->name) {
- debug_printf("%s: help for %s: %s [0x%lx]\n", __FUNCTION__, name, flags->name, flags->value);
- flags++;
- }
+ _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*"PRIx64"]%s%s\n", namealign, flags->name,
+ (int)sizeof(uint64_t)*CHAR_BIT/4, flags->value,
+ flags->desc ? " " : "", flags->desc ? flags->desc : "");
}
else {
result = 0;
while( flags->name ) {
- if (!util_strcmp(str, "all") || util_strstr(str, flags->name ))
+ if (str_has_option(str, flags->name))
result |= flags->value;
++flags;
}
}
- 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);
+ if (debug_get_option_should_print()) {
+ if (str) {
+ debug_printf("%s: %s = 0x%"PRIx64" (%s)\n", __FUNCTION__, name, result, str);
+ } else {
+ debug_printf("%s: %s = 0x%"PRIx64"\n", __FUNCTION__, name, result);
+ }
}
return result;
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");
+ os_abort();
}
while(names->name) {
if((names->value & value) == names->value) {
if (!first)
- util_strncat(output, "|", sizeof(output));
+ util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
else
first = 0;
- util_strncat(output, names->name, sizeof(output) - 1);
+ util_strncat(output, names->name, sizeof(output) - strlen(output) - 1);
output[sizeof(output) - 1] = '\0';
value &= ~names->value;
}
if (value) {
if (!first)
- util_strncat(output, "|", sizeof(output));
+ util_strncat(output, "|", sizeof(output) - strlen(output) - 1);
else
first = 0;
util_snprintf(rest, sizeof(rest), "0x%08lx", value);
- util_strncat(output, rest, sizeof(output) - 1);
+ util_strncat(output, rest, sizeof(output) - strlen(output) - 1);
output[sizeof(output) - 1] = '\0';
}
#endif
+/** Return string name of given primitive type */
+const char *
+u_prim_name(unsigned prim)
+{
+ static const struct debug_named_value names[] = {
+ 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),
+ DEBUG_NAMED_VALUE(PIPE_PRIM_LINES_ADJACENCY),
+ DEBUG_NAMED_VALUE(PIPE_PRIM_LINE_STRIP_ADJACENCY),
+ DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLES_ADJACENCY),
+ DEBUG_NAMED_VALUE(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY),
+ DEBUG_NAMED_VALUE_END
+ };
+ return debug_dump_enum(names, prim);
+}
+
+
-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
-};
+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;
+}
-const char *u_prim_name( unsigned prim )
+void debug_funclog_exit(const char* f, const int line, const char* file)
{
- return debug_dump_enum(pipe_prim_names, prim);
+ --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).
+ * Dump an image to .ppm file.
* \param format PIPE_FORMAT_x
* \param cpp bytes per pixel
* \param width width in pixels
* \param stride row stride in bytes
*/
void debug_dump_image(const char *prefix,
- unsigned format, unsigned cpp,
+ enum pipe_format 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];
+ unsigned char *rgb8;
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;
- }
+ rgb8 = MALLOC(height * width * 3);
+ if (!rgb8) {
+ return;
+ }
+ util_format_translate(
+ PIPE_FORMAT_R8G8B8_UNORM,
+ rgb8, width * 3,
+ 0, 0,
+ format,
+ data, stride,
+ 0, 0, width, height);
+
+ /* Must be opened in binary mode or DOS line ending causes data
+ * to be read with one byte offset.
+ */
+ f = fopen(filename, "wb");
+ if (f) {
fprintf(f, "P6\n");
- fprintf(f, "# ppm-file created by osdemo.c\n");
+ fprintf(f, "# ppm-file created by gallium\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 */
- }
- }
+ fwrite(rgb8, 1, height * width * 3, f);
fclose(f);
}
else {
fprintf(stderr, "Can't open %s for writing\n", filename);
}
-#endif
+
+ FREE(rgb8);
}
+/* FIXME: dump resources, not surfaces... */
void debug_dump_surface(struct pipe_context *pipe,
- const char *prefix,
- struct pipe_surface *surface)
+ const char *prefix,
+ struct pipe_surface *surface)
{
- struct pipe_texture *texture;
+ struct pipe_resource *texture;
struct pipe_transfer *transfer;
void *data;
*/
texture = surface->texture;
- transfer = pipe->get_tex_transfer(pipe, texture, surface->face,
- surface->level, surface->zslice,
- PIPE_TRANSFER_READ, 0, 0, surface->width,
- surface->height);
-
- data = pipe->transfer_map(pipe, transfer);
- if(!data)
- goto error;
-
- debug_dump_image(prefix,
+ data = pipe_transfer_map(pipe, texture, surface->u.tex.level,
+ surface->u.tex.first_layer,
+ PIPE_TRANSFER_READ,
+ 0, 0, surface->width, surface->height, &transfer);
+ if (!data)
+ return;
+
+ debug_dump_image(prefix,
texture->format,
- util_format_get_blocksize(texture->format),
- util_format_get_nblocksx(texture->format, transfer->width),
- util_format_get_nblocksy(texture->format, transfer->height),
+ 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->tex_transfer_destroy(pipe, transfer);
}
void debug_dump_texture(struct pipe_context *pipe,
const char *prefix,
- struct pipe_texture *texture)
+ struct pipe_resource *texture)
{
- struct pipe_surface *surface;
- struct pipe_screen *screen;
+ struct pipe_surface *surface, surf_tmpl;
if (!texture)
return;
- screen = texture->screen;
-
- /* XXX for now, just dump image for face=0, level=0 */
- surface = screen->get_tex_surface(screen, texture, 0, 0, 0,
- PIPE_TEXTURE_USAGE_SAMPLER);
+ /* XXX for now, just dump image for layer=0, level=0 */
+ u_surface_default_template(&surf_tmpl, texture);
+ surface = pipe->create_surface(pipe, texture, &surf_tmpl);
if (surface) {
debug_dump_surface(pipe, prefix, surface);
- screen->tex_surface_destroy(surface);
+ pipe->surface_destroy(pipe, surface);
}
}
void
debug_dump_surface_bmp(struct pipe_context *pipe,
- const char *filename,
+ const char *filename,
struct pipe_surface *surface)
{
-#ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
struct pipe_transfer *transfer;
- struct pipe_texture *texture = surface->texture;
+ struct pipe_resource *texture = surface->texture;
+ void *ptr;
- transfer = pipe->get_tex_transfer(pipe, texture, surface->face,
- surface->level, surface->zslice,
- PIPE_TRANSFER_READ, 0, 0, surface->width,
- surface->height);
+ ptr = pipe_transfer_map(pipe, texture, surface->u.tex.level,
+ surface->u.tex.first_layer, PIPE_TRANSFER_READ,
+ 0, 0, surface->width, surface->height, &transfer);
- debug_dump_transfer_bmp(pipe, filename, transfer);
+ debug_dump_transfer_bmp(pipe, filename, transfer, ptr);
- pipe->tex_transfer_destroy(pipe, transfer);
-#endif
+ pipe->transfer_unmap(pipe, transfer);
}
void
debug_dump_transfer_bmp(struct pipe_context *pipe,
const char *filename,
- struct pipe_transfer *transfer)
+ struct pipe_transfer *transfer, void *ptr)
{
-#ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
float *rgba;
if (!transfer)
goto error1;
- rgba = MALLOC(transfer->width*transfer->height*4*sizeof(float));
- if(!rgba)
+ 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->width, transfer->height,
+ pipe_get_tile_rgba(transfer, ptr, 0, 0,
+ transfer->box.width, transfer->box.height,
rgba);
debug_dump_float_rgba_bmp(filename,
- transfer->width, transfer->height,
- rgba, transfer->width);
+ transfer->box.width, transfer->box.height,
+ rgba, transfer->box.width);
FREE(rgba);
error1:
;
-#endif
}
void
unsigned width, unsigned height,
float *rgba, unsigned stride)
{
-#ifndef PIPE_SUBSYSTEM_WINDOWS_MINIPORT
- struct os_stream *stream;
+ FILE *stream;
struct bmp_file_header bmfh;
struct bmp_info_header bmih;
unsigned x, y;
- if(!rgba)
+ if (!rgba)
goto error1;
bmfh.bfType = 0x4d42;
bmih.biClrUsed = 0;
bmih.biClrImportant = 0;
- stream = os_file_stream_create(filename);
- if(!stream)
+ stream = fopen(filename, "wb");
+ if (!stream)
goto error1;
- os_stream_write(stream, &bmfh, 14);
- os_stream_write(stream, &bmih, 40);
+ fwrite(&bmfh, 14, 1, stream);
+ fwrite(&bmih, 40, 1, stream);
y = height;
while(y--) {
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);
+ pixel.rgbAlpha = float_to_ubyte(ptr[x*4 + 3]);
+ fwrite(&pixel, 1, 4, stream);
}
}
- os_stream_close(stream);
+ fclose(stream);
error1:
;
-#endif
}
+void
+debug_dump_ubyte_rgba_bmp(const char *filename,
+ unsigned width, unsigned height,
+ const ubyte *rgba, unsigned stride)
+{
+ FILE *stream;
+ struct bmp_file_header bmfh;
+ struct bmp_info_header bmih;
+ unsigned x, y;
+
+ assert(rgba);
+ 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 = fopen(filename, "wb");
+ assert(stream);
+ if(!stream)
+ goto error1;
+
+ fwrite(&bmfh, 14, 1, stream);
+ fwrite(&bmih, 40, 1, stream);
+
+ y = height;
+ while(y--) {
+ const ubyte *ptr = rgba + (stride * y * 4);
+ for(x = 0; x < width; ++x)
+ {
+ struct bmp_rgb_quad pixel;
+ pixel.rgbRed = ptr[x*4 + 0];
+ pixel.rgbGreen = ptr[x*4 + 1];
+ pixel.rgbBlue = ptr[x*4 + 2];
+ pixel.rgbAlpha = ptr[x*4 + 3];
+ fwrite(&pixel, 1, 4, stream);
+ }
+ }
+
+ fclose(stream);
+error1:
+ ;
+}
+
+
+/**
+ * Print PIPE_TRANSFER_x flags with a message.
+ */
+void
+debug_print_transfer_flags(const char *msg, unsigned usage)
+{
+ static const struct debug_named_value names[] = {
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_READ),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_WRITE),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_MAP_DIRECTLY),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_RANGE),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_DONTBLOCK),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_UNSYNCHRONIZED),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_FLUSH_EXPLICIT),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_PERSISTENT),
+ DEBUG_NAMED_VALUE(PIPE_TRANSFER_COHERENT),
+ DEBUG_NAMED_VALUE_END
+ };
+
+ debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
+}
+
+
+/**
+ * Print PIPE_BIND_x flags with a message.
+ */
+void
+debug_print_bind_flags(const char *msg, unsigned usage)
+{
+ static const struct debug_named_value names[] = {
+ DEBUG_NAMED_VALUE(PIPE_BIND_DEPTH_STENCIL),
+ DEBUG_NAMED_VALUE(PIPE_BIND_RENDER_TARGET),
+ DEBUG_NAMED_VALUE(PIPE_BIND_BLENDABLE),
+ DEBUG_NAMED_VALUE(PIPE_BIND_SAMPLER_VIEW),
+ DEBUG_NAMED_VALUE(PIPE_BIND_VERTEX_BUFFER),
+ DEBUG_NAMED_VALUE(PIPE_BIND_INDEX_BUFFER),
+ DEBUG_NAMED_VALUE(PIPE_BIND_CONSTANT_BUFFER),
+ DEBUG_NAMED_VALUE(PIPE_BIND_DISPLAY_TARGET),
+ DEBUG_NAMED_VALUE(PIPE_BIND_TRANSFER_WRITE),
+ DEBUG_NAMED_VALUE(PIPE_BIND_TRANSFER_READ),
+ DEBUG_NAMED_VALUE(PIPE_BIND_STREAM_OUTPUT),
+ DEBUG_NAMED_VALUE(PIPE_BIND_CURSOR),
+ DEBUG_NAMED_VALUE(PIPE_BIND_CUSTOM),
+ DEBUG_NAMED_VALUE(PIPE_BIND_GLOBAL),
+ DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_BUFFER),
+ DEBUG_NAMED_VALUE(PIPE_BIND_SHADER_IMAGE),
+ DEBUG_NAMED_VALUE(PIPE_BIND_COMPUTE_RESOURCE),
+ DEBUG_NAMED_VALUE(PIPE_BIND_COMMAND_ARGS_BUFFER),
+ DEBUG_NAMED_VALUE(PIPE_BIND_SCANOUT),
+ DEBUG_NAMED_VALUE(PIPE_BIND_SHARED),
+ DEBUG_NAMED_VALUE(PIPE_BIND_LINEAR),
+ DEBUG_NAMED_VALUE_END
+ };
+
+ debug_printf("%s: %s\n", msg, debug_dump_flags(names, usage));
+}
+
+
+/**
+ * Print PIPE_USAGE_x enum values with a message.
+ */
+void
+debug_print_usage_enum(const char *msg, unsigned usage)
+{
+ static const struct debug_named_value names[] = {
+ DEBUG_NAMED_VALUE(PIPE_USAGE_DEFAULT),
+ DEBUG_NAMED_VALUE(PIPE_USAGE_IMMUTABLE),
+ DEBUG_NAMED_VALUE(PIPE_USAGE_DYNAMIC),
+ DEBUG_NAMED_VALUE(PIPE_USAGE_STREAM),
+ DEBUG_NAMED_VALUE(PIPE_USAGE_STAGING),
+ DEBUG_NAMED_VALUE_END
+ };
+
+ debug_printf("%s: %s\n", msg, debug_dump_enum(names, usage));
+}
+
+
#endif