| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/Makefile.am |
|---|
| 0,0 → 1,14 |
| include $(top_srcdir)/src/gallium/Automake.inc |
| AM_CFLAGS = \ |
| $(GALLIUM_CFLAGS) \ |
| $(VISIBILITY_CFLAGS) |
| noinst_LTLIBRARIES = libtrace.la |
| libtrace_la_SOURCES = \ |
| tr_context.c \ |
| tr_dump.c \ |
| tr_dump_state.c \ |
| tr_screen.c \ |
| tr_texture.c |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/Makefile.in |
|---|
| 0,0 → 1,766 |
| # Makefile.in generated by automake 1.14 from Makefile.am. |
| # @configure_input@ |
| # Copyright (C) 1994-2013 Free Software Foundation, Inc. |
| # This Makefile.in is free software; the Free Software Foundation |
| # gives unlimited permission to copy and/or distribute it, |
| # with or without modifications, as long as this notice is preserved. |
| # This program is distributed in the hope that it will be useful, |
| # but WITHOUT ANY WARRANTY, to the extent permitted by law; without |
| # even the implied warranty of MERCHANTABILITY or FITNESS FOR A |
| # PARTICULAR PURPOSE. |
| @SET_MAKE@ |
| VPATH = @srcdir@ |
| am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)' |
| am__make_running_with_option = \ |
| case $${target_option-} in \ |
| ?) ;; \ |
| *) echo "am__make_running_with_option: internal error: invalid" \ |
| "target option '$${target_option-}' specified" >&2; \ |
| exit 1;; \ |
| esac; \ |
| has_opt=no; \ |
| sane_makeflags=$$MAKEFLAGS; \ |
| if $(am__is_gnu_make); then \ |
| sane_makeflags=$$MFLAGS; \ |
| else \ |
| case $$MAKEFLAGS in \ |
| *\\[\ \ ]*) \ |
| bs=\\; \ |
| sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ |
| | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ |
| esac; \ |
| fi; \ |
| skip_next=no; \ |
| strip_trailopt () \ |
| { \ |
| flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ |
| }; \ |
| for flg in $$sane_makeflags; do \ |
| test $$skip_next = yes && { skip_next=no; continue; }; \ |
| case $$flg in \ |
| *=*|--*) continue;; \ |
| -*I) strip_trailopt 'I'; skip_next=yes;; \ |
| -*I?*) strip_trailopt 'I';; \ |
| -*O) strip_trailopt 'O'; skip_next=yes;; \ |
| -*O?*) strip_trailopt 'O';; \ |
| -*l) strip_trailopt 'l'; skip_next=yes;; \ |
| -*l?*) strip_trailopt 'l';; \ |
| -[dEDm]) skip_next=yes;; \ |
| -[JT]) skip_next=yes;; \ |
| esac; \ |
| case $$flg in \ |
| *$$target_option*) has_opt=yes; break;; \ |
| esac; \ |
| done; \ |
| test $$has_opt = yes |
| am__make_dryrun = (target_option=n; $(am__make_running_with_option)) |
| am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) |
| pkgdatadir = $(datadir)/@PACKAGE@ |
| pkgincludedir = $(includedir)/@PACKAGE@ |
| pkglibdir = $(libdir)/@PACKAGE@ |
| pkglibexecdir = $(libexecdir)/@PACKAGE@ |
| am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd |
| install_sh_DATA = $(install_sh) -c -m 644 |
| install_sh_PROGRAM = $(install_sh) -c |
| install_sh_SCRIPT = $(install_sh) -c |
| INSTALL_HEADER = $(INSTALL_DATA) |
| transform = $(program_transform_name) |
| NORMAL_INSTALL = : |
| PRE_INSTALL = : |
| POST_INSTALL = : |
| NORMAL_UNINSTALL = : |
| PRE_UNINSTALL = : |
| POST_UNINSTALL = : |
| build_triplet = @build@ |
| host_triplet = @host@ |
| target_triplet = @target@ |
| DIST_COMMON = $(top_srcdir)/src/gallium/Automake.inc \ |
| $(srcdir)/Makefile.in $(srcdir)/Makefile.am \ |
| $(top_srcdir)/bin/depcomp README |
| subdir = src/gallium/drivers/trace |
| ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 |
| am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_bison.m4 \ |
| $(top_srcdir)/m4/ax_prog_cc_for_build.m4 \ |
| $(top_srcdir)/m4/ax_prog_cxx_for_build.m4 \ |
| $(top_srcdir)/m4/ax_prog_flex.m4 \ |
| $(top_srcdir)/m4/ax_pthread.m4 \ |
| $(top_srcdir)/m4/ax_python_module.m4 \ |
| $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ |
| $(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \ |
| $(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac |
| am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ |
| $(ACLOCAL_M4) |
| mkinstalldirs = $(install_sh) -d |
| CONFIG_CLEAN_FILES = |
| CONFIG_CLEAN_VPATH_FILES = |
| LTLIBRARIES = $(noinst_LTLIBRARIES) |
| libtrace_la_LIBADD = |
| am_libtrace_la_OBJECTS = tr_context.lo tr_dump.lo tr_dump_state.lo \ |
| tr_screen.lo tr_texture.lo |
| libtrace_la_OBJECTS = $(am_libtrace_la_OBJECTS) |
| AM_V_lt = $(am__v_lt_@AM_V@) |
| am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) |
| am__v_lt_0 = --silent |
| am__v_lt_1 = |
| AM_V_P = $(am__v_P_@AM_V@) |
| am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) |
| am__v_P_0 = false |
| am__v_P_1 = : |
| AM_V_GEN = $(am__v_GEN_@AM_V@) |
| am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) |
| am__v_GEN_0 = @echo " GEN " $@; |
| am__v_GEN_1 = |
| AM_V_at = $(am__v_at_@AM_V@) |
| am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) |
| am__v_at_0 = @ |
| am__v_at_1 = |
| DEFAULT_INCLUDES = -I.@am__isrc@ |
| depcomp = $(SHELL) $(top_srcdir)/bin/depcomp |
| am__depfiles_maybe = depfiles |
| am__mv = mv -f |
| COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ |
| $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) |
| LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ |
| $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ |
| $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ |
| $(AM_CFLAGS) $(CFLAGS) |
| AM_V_CC = $(am__v_CC_@AM_V@) |
| am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) |
| am__v_CC_0 = @echo " CC " $@; |
| am__v_CC_1 = |
| CCLD = $(CC) |
| LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ |
| $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ |
| $(AM_LDFLAGS) $(LDFLAGS) -o $@ |
| AM_V_CCLD = $(am__v_CCLD_@AM_V@) |
| am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) |
| am__v_CCLD_0 = @echo " CCLD " $@; |
| am__v_CCLD_1 = |
| SOURCES = $(libtrace_la_SOURCES) |
| DIST_SOURCES = $(libtrace_la_SOURCES) |
| am__can_run_installinfo = \ |
| case $$AM_UPDATE_INFO_DIR in \ |
| n|no|NO) false;; \ |
| *) (install-info --version) >/dev/null 2>&1;; \ |
| esac |
| am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) |
| # Read a list of newline-separated strings from the standard input, |
| # and print each of them once, without duplicates. Input order is |
| # *not* preserved. |
| am__uniquify_input = $(AWK) '\ |
| BEGIN { nonempty = 0; } \ |
| { items[$$0] = 1; nonempty = 1; } \ |
| END { if (nonempty) { for (i in items) print i; }; } \ |
| ' |
| # Make sure the list of sources is unique. This is necessary because, |
| # e.g., the same source file might be shared among _SOURCES variables |
| # for different programs/libraries. |
| am__define_uniq_tagged_files = \ |
| list='$(am__tagged_files)'; \ |
| unique=`for i in $$list; do \ |
| if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ |
| done | $(am__uniquify_input)` |
| ETAGS = etags |
| CTAGS = ctags |
| DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) |
| ACLOCAL = @ACLOCAL@ |
| AMTAR = @AMTAR@ |
| AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ |
| AR = @AR@ |
| AUTOCONF = @AUTOCONF@ |
| AUTOHEADER = @AUTOHEADER@ |
| AUTOMAKE = @AUTOMAKE@ |
| AWK = @AWK@ |
| BUILD_EXEEXT = @BUILD_EXEEXT@ |
| BUILD_OBJEXT = @BUILD_OBJEXT@ |
| CC = @CC@ |
| CCAS = @CCAS@ |
| CCASDEPMODE = @CCASDEPMODE@ |
| CCASFLAGS = @CCASFLAGS@ |
| CCDEPMODE = @CCDEPMODE@ |
| CC_FOR_BUILD = @CC_FOR_BUILD@ |
| CFLAGS = @CFLAGS@ |
| CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@ |
| CLANG_RESOURCE_DIR = @CLANG_RESOURCE_DIR@ |
| CLOCK_LIB = @CLOCK_LIB@ |
| CPP = @CPP@ |
| CPPFLAGS = @CPPFLAGS@ |
| CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@ |
| CPP_FOR_BUILD = @CPP_FOR_BUILD@ |
| CXX = @CXX@ |
| CXXCPP = @CXXCPP@ |
| CXXCPPFLAGS_FOR_BUILD = @CXXCPPFLAGS_FOR_BUILD@ |
| CXXCPP_FOR_BUILD = @CXXCPP_FOR_BUILD@ |
| CXXDEPMODE = @CXXDEPMODE@ |
| CXXFLAGS = @CXXFLAGS@ |
| CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@ |
| CXX_FOR_BUILD = @CXX_FOR_BUILD@ |
| CYGPATH_W = @CYGPATH_W@ |
| DEFINES = @DEFINES@ |
| DEFINES_FOR_BUILD = @DEFINES_FOR_BUILD@ |
| DEFS = @DEFS@ |
| DEPDIR = @DEPDIR@ |
| DLLTOOL = @DLLTOOL@ |
| DLOPEN_LIBS = @DLOPEN_LIBS@ |
| DRI2PROTO_CFLAGS = @DRI2PROTO_CFLAGS@ |
| DRI2PROTO_LIBS = @DRI2PROTO_LIBS@ |
| DRIGL_CFLAGS = @DRIGL_CFLAGS@ |
| DRIGL_LIBS = @DRIGL_LIBS@ |
| DRI_DRIVER_INSTALL_DIR = @DRI_DRIVER_INSTALL_DIR@ |
| DRI_DRIVER_SEARCH_DIR = @DRI_DRIVER_SEARCH_DIR@ |
| DRI_LIB_DEPS = @DRI_LIB_DEPS@ |
| DRI_PC_REQ_PRIV = @DRI_PC_REQ_PRIV@ |
| DSYMUTIL = @DSYMUTIL@ |
| DUMPBIN = @DUMPBIN@ |
| ECHO_C = @ECHO_C@ |
| ECHO_N = @ECHO_N@ |
| ECHO_T = @ECHO_T@ |
| EGL_CFLAGS = @EGL_CFLAGS@ |
| EGL_CLIENT_APIS = @EGL_CLIENT_APIS@ |
| EGL_DRIVER_INSTALL_DIR = @EGL_DRIVER_INSTALL_DIR@ |
| EGL_LIB_DEPS = @EGL_LIB_DEPS@ |
| EGL_LIB_GLOB = @EGL_LIB_GLOB@ |
| EGL_LIB_NAME = @EGL_LIB_NAME@ |
| EGL_NATIVE_PLATFORM = @EGL_NATIVE_PLATFORM@ |
| EGL_PLATFORMS = @EGL_PLATFORMS@ |
| EGREP = @EGREP@ |
| ELF_LIB = @ELF_LIB@ |
| EXEEXT = @EXEEXT@ |
| EXPAT_INCLUDES = @EXPAT_INCLUDES@ |
| FGREP = @FGREP@ |
| FREEDRENO_CFLAGS = @FREEDRENO_CFLAGS@ |
| FREEDRENO_LIBS = @FREEDRENO_LIBS@ |
| GALLIUM_DRI_LIB_DEPS = @GALLIUM_DRI_LIB_DEPS@ |
| GALLIUM_PIPE_LOADER_DEFINES = @GALLIUM_PIPE_LOADER_DEFINES@ |
| GALLIUM_PIPE_LOADER_LIBS = @GALLIUM_PIPE_LOADER_LIBS@ |
| GALLIUM_PIPE_LOADER_XCB_CFLAGS = @GALLIUM_PIPE_LOADER_XCB_CFLAGS@ |
| GALLIUM_PIPE_LOADER_XCB_LIBS = @GALLIUM_PIPE_LOADER_XCB_LIBS@ |
| GBM_PC_LIB_PRIV = @GBM_PC_LIB_PRIV@ |
| GBM_PC_REQ_PRIV = @GBM_PC_REQ_PRIV@ |
| GLAPI_LIB_GLOB = @GLAPI_LIB_GLOB@ |
| GLAPI_LIB_NAME = @GLAPI_LIB_NAME@ |
| GLESv1_CM_LIB_DEPS = @GLESv1_CM_LIB_DEPS@ |
| GLESv1_CM_LIB_GLOB = @GLESv1_CM_LIB_GLOB@ |
| GLESv1_CM_LIB_NAME = @GLESv1_CM_LIB_NAME@ |
| GLESv1_CM_PC_LIB_PRIV = @GLESv1_CM_PC_LIB_PRIV@ |
| GLESv2_LIB_DEPS = @GLESv2_LIB_DEPS@ |
| GLESv2_LIB_GLOB = @GLESv2_LIB_GLOB@ |
| GLESv2_LIB_NAME = @GLESv2_LIB_NAME@ |
| GLESv2_PC_LIB_PRIV = @GLESv2_PC_LIB_PRIV@ |
| GLPROTO_CFLAGS = @GLPROTO_CFLAGS@ |
| GLPROTO_LIBS = @GLPROTO_LIBS@ |
| GLX_TLS = @GLX_TLS@ |
| GL_LIB = @GL_LIB@ |
| GL_LIB_DEPS = @GL_LIB_DEPS@ |
| GL_LIB_GLOB = @GL_LIB_GLOB@ |
| GL_LIB_NAME = @GL_LIB_NAME@ |
| GL_PC_CFLAGS = @GL_PC_CFLAGS@ |
| GL_PC_LIB_PRIV = @GL_PC_LIB_PRIV@ |
| GL_PC_REQ_PRIV = @GL_PC_REQ_PRIV@ |
| GREP = @GREP@ |
| HAVE_XF86VIDMODE = @HAVE_XF86VIDMODE@ |
| INDENT = @INDENT@ |
| INDENT_FLAGS = @INDENT_FLAGS@ |
| INSTALL = @INSTALL@ |
| INSTALL_DATA = @INSTALL_DATA@ |
| INSTALL_PROGRAM = @INSTALL_PROGRAM@ |
| INSTALL_SCRIPT = @INSTALL_SCRIPT@ |
| INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ |
| INTEL_CFLAGS = @INTEL_CFLAGS@ |
| INTEL_LIBS = @INTEL_LIBS@ |
| LD = @LD@ |
| LDFLAGS = @LDFLAGS@ |
| LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@ |
| LEX = @LEX@ |
| LEXLIB = @LEXLIB@ |
| LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@ |
| LIBCLC_INCLUDEDIR = @LIBCLC_INCLUDEDIR@ |
| LIBCLC_LIBEXECDIR = @LIBCLC_LIBEXECDIR@ |
| LIBDRM_CFLAGS = @LIBDRM_CFLAGS@ |
| LIBDRM_LIBS = @LIBDRM_LIBS@ |
| LIBDRM_XORG_CFLAGS = @LIBDRM_XORG_CFLAGS@ |
| LIBDRM_XORG_LIBS = @LIBDRM_XORG_LIBS@ |
| LIBKMS_XORG_CFLAGS = @LIBKMS_XORG_CFLAGS@ |
| LIBKMS_XORG_LIBS = @LIBKMS_XORG_LIBS@ |
| LIBOBJS = @LIBOBJS@ |
| LIBS = @LIBS@ |
| LIBTOOL = @LIBTOOL@ |
| LIBUDEV_CFLAGS = @LIBUDEV_CFLAGS@ |
| LIBUDEV_LIBS = @LIBUDEV_LIBS@ |
| LIB_DIR = @LIB_DIR@ |
| LIPO = @LIPO@ |
| LLVM_BINDIR = @LLVM_BINDIR@ |
| LLVM_CFLAGS = @LLVM_CFLAGS@ |
| LLVM_CONFIG = @LLVM_CONFIG@ |
| LLVM_CPPFLAGS = @LLVM_CPPFLAGS@ |
| LLVM_CXXFLAGS = @LLVM_CXXFLAGS@ |
| LLVM_INCLUDEDIR = @LLVM_INCLUDEDIR@ |
| LLVM_LDFLAGS = @LLVM_LDFLAGS@ |
| LLVM_LIBDIR = @LLVM_LIBDIR@ |
| LLVM_LIBS = @LLVM_LIBS@ |
| LLVM_VERSION = @LLVM_VERSION@ |
| LN_S = @LN_S@ |
| LTLIBOBJS = @LTLIBOBJS@ |
| MAKE = @MAKE@ |
| MAKEINFO = @MAKEINFO@ |
| MANIFEST_TOOL = @MANIFEST_TOOL@ |
| MESA_LLVM = @MESA_LLVM@ |
| MKDIR_P = @MKDIR_P@ |
| NM = @NM@ |
| NMEDIT = @NMEDIT@ |
| NOUVEAU_CFLAGS = @NOUVEAU_CFLAGS@ |
| NOUVEAU_LIBS = @NOUVEAU_LIBS@ |
| OBJDUMP = @OBJDUMP@ |
| OBJEXT = @OBJEXT@ |
| OPENCL_LIB_INSTALL_DIR = @OPENCL_LIB_INSTALL_DIR@ |
| OSMESA_LIB = @OSMESA_LIB@ |
| OSMESA_LIB_DEPS = @OSMESA_LIB_DEPS@ |
| OSMESA_LIB_NAME = @OSMESA_LIB_NAME@ |
| OSMESA_MESA_DEPS = @OSMESA_MESA_DEPS@ |
| OSMESA_PC_LIB_PRIV = @OSMESA_PC_LIB_PRIV@ |
| OSMESA_PC_REQ = @OSMESA_PC_REQ@ |
| OSMESA_VERSION = @OSMESA_VERSION@ |
| OTOOL = @OTOOL@ |
| OTOOL64 = @OTOOL64@ |
| PACKAGE = @PACKAGE@ |
| PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ |
| PACKAGE_NAME = @PACKAGE_NAME@ |
| PACKAGE_STRING = @PACKAGE_STRING@ |
| PACKAGE_TARNAME = @PACKAGE_TARNAME@ |
| PACKAGE_URL = @PACKAGE_URL@ |
| PACKAGE_VERSION = @PACKAGE_VERSION@ |
| PATH_SEPARATOR = @PATH_SEPARATOR@ |
| PERL = @PERL@ |
| PKG_CONFIG = @PKG_CONFIG@ |
| PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ |
| PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ |
| POSIX_SHELL = @POSIX_SHELL@ |
| PTHREAD_CC = @PTHREAD_CC@ |
| PTHREAD_CFLAGS = @PTHREAD_CFLAGS@ |
| PTHREAD_LIBS = @PTHREAD_LIBS@ |
| PYTHON2 = @PYTHON2@ |
| RADEON_CFLAGS = @RADEON_CFLAGS@ |
| RADEON_LIBS = @RADEON_LIBS@ |
| RANLIB = @RANLIB@ |
| SED = @SED@ |
| SELINUX_LIBS = @SELINUX_LIBS@ |
| SET_MAKE = @SET_MAKE@ |
| SHELL = @SHELL@ |
| STRIP = @STRIP@ |
| VDPAU_CFLAGS = @VDPAU_CFLAGS@ |
| VDPAU_LIBS = @VDPAU_LIBS@ |
| VDPAU_LIB_INSTALL_DIR = @VDPAU_LIB_INSTALL_DIR@ |
| VDPAU_MAJOR = @VDPAU_MAJOR@ |
| VDPAU_MINOR = @VDPAU_MINOR@ |
| VERSION = @VERSION@ |
| VG_LIB_DEPS = @VG_LIB_DEPS@ |
| VG_LIB_GLOB = @VG_LIB_GLOB@ |
| VG_LIB_NAME = @VG_LIB_NAME@ |
| VG_PC_LIB_PRIV = @VG_PC_LIB_PRIV@ |
| VISIBILITY_CFLAGS = @VISIBILITY_CFLAGS@ |
| VISIBILITY_CXXFLAGS = @VISIBILITY_CXXFLAGS@ |
| WAYLAND_CFLAGS = @WAYLAND_CFLAGS@ |
| WAYLAND_LIBS = @WAYLAND_LIBS@ |
| WAYLAND_SCANNER = @WAYLAND_SCANNER@ |
| X11_INCLUDES = @X11_INCLUDES@ |
| XA_MAJOR = @XA_MAJOR@ |
| XA_MINOR = @XA_MINOR@ |
| XA_TINY = @XA_TINY@ |
| XA_VERSION = @XA_VERSION@ |
| XCB_DRI2_CFLAGS = @XCB_DRI2_CFLAGS@ |
| XCB_DRI2_LIBS = @XCB_DRI2_LIBS@ |
| XEXT_CFLAGS = @XEXT_CFLAGS@ |
| XEXT_LIBS = @XEXT_LIBS@ |
| XF86VIDMODE_CFLAGS = @XF86VIDMODE_CFLAGS@ |
| XF86VIDMODE_LIBS = @XF86VIDMODE_LIBS@ |
| XLIBGL_CFLAGS = @XLIBGL_CFLAGS@ |
| XLIBGL_LIBS = @XLIBGL_LIBS@ |
| XORG_CFLAGS = @XORG_CFLAGS@ |
| XORG_DRIVER_INSTALL_DIR = @XORG_DRIVER_INSTALL_DIR@ |
| XORG_LIBS = @XORG_LIBS@ |
| XVMC_CFLAGS = @XVMC_CFLAGS@ |
| XVMC_LIBS = @XVMC_LIBS@ |
| XVMC_LIB_INSTALL_DIR = @XVMC_LIB_INSTALL_DIR@ |
| XVMC_MAJOR = @XVMC_MAJOR@ |
| XVMC_MINOR = @XVMC_MINOR@ |
| YACC = @YACC@ |
| YFLAGS = @YFLAGS@ |
| abs_builddir = @abs_builddir@ |
| abs_srcdir = @abs_srcdir@ |
| abs_top_builddir = @abs_top_builddir@ |
| abs_top_srcdir = @abs_top_srcdir@ |
| ac_ct_AR = @ac_ct_AR@ |
| ac_ct_CC = @ac_ct_CC@ |
| ac_ct_CC_FOR_BUILD = @ac_ct_CC_FOR_BUILD@ |
| ac_ct_CXX = @ac_ct_CXX@ |
| ac_ct_CXX_FOR_BUILD = @ac_ct_CXX_FOR_BUILD@ |
| ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ |
| am__include = @am__include@ |
| am__leading_dot = @am__leading_dot@ |
| am__quote = @am__quote@ |
| am__tar = @am__tar@ |
| am__untar = @am__untar@ |
| ax_pthread_config = @ax_pthread_config@ |
| bindir = @bindir@ |
| build = @build@ |
| build_alias = @build_alias@ |
| build_cpu = @build_cpu@ |
| build_os = @build_os@ |
| build_vendor = @build_vendor@ |
| builddir = @builddir@ |
| datadir = @datadir@ |
| datarootdir = @datarootdir@ |
| docdir = @docdir@ |
| dvidir = @dvidir@ |
| exec_prefix = @exec_prefix@ |
| host = @host@ |
| host_alias = @host_alias@ |
| host_cpu = @host_cpu@ |
| host_os = @host_os@ |
| host_vendor = @host_vendor@ |
| htmldir = @htmldir@ |
| includedir = @includedir@ |
| infodir = @infodir@ |
| install_sh = @install_sh@ |
| libdir = @libdir@ |
| libexecdir = @libexecdir@ |
| localedir = @localedir@ |
| localstatedir = @localstatedir@ |
| mandir = @mandir@ |
| mkdir_p = @mkdir_p@ |
| oldincludedir = @oldincludedir@ |
| pdfdir = @pdfdir@ |
| prefix = @prefix@ |
| program_transform_name = @program_transform_name@ |
| psdir = @psdir@ |
| sbindir = @sbindir@ |
| sharedstatedir = @sharedstatedir@ |
| srcdir = @srcdir@ |
| sysconfdir = @sysconfdir@ |
| target = @target@ |
| target_alias = @target_alias@ |
| target_cpu = @target_cpu@ |
| target_os = @target_os@ |
| target_vendor = @target_vendor@ |
| top_build_prefix = @top_build_prefix@ |
| top_builddir = @top_builddir@ |
| top_srcdir = @top_srcdir@ |
| GALLIUM_CFLAGS = \ |
| -I$(top_srcdir)/include \ |
| -I$(top_srcdir)/src/gallium/include \ |
| -I$(top_srcdir)/src/gallium/auxiliary \ |
| $(DEFINES) |
| AM_CFLAGS = \ |
| $(GALLIUM_CFLAGS) \ |
| $(VISIBILITY_CFLAGS) |
| noinst_LTLIBRARIES = libtrace.la |
| libtrace_la_SOURCES = \ |
| tr_context.c \ |
| tr_dump.c \ |
| tr_dump_state.c \ |
| tr_screen.c \ |
| tr_texture.c |
| all: all-am |
| .SUFFIXES: |
| .SUFFIXES: .c .lo .o .obj |
| $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(top_srcdir)/src/gallium/Automake.inc $(am__configure_deps) |
| @for dep in $?; do \ |
| case '$(am__configure_deps)' in \ |
| *$$dep*) \ |
| ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ |
| && { if test -f $@; then exit 0; else break; fi; }; \ |
| exit 1;; \ |
| esac; \ |
| done; \ |
| echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/gallium/drivers/trace/Makefile'; \ |
| $(am__cd) $(top_srcdir) && \ |
| $(AUTOMAKE) --foreign src/gallium/drivers/trace/Makefile |
| .PRECIOUS: Makefile |
| Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status |
| @case '$?' in \ |
| *config.status*) \ |
| cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ |
| *) \ |
| echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ |
| cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ |
| esac; |
| $(top_srcdir)/src/gallium/Automake.inc: |
| $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) |
| cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh |
| $(top_srcdir)/configure: $(am__configure_deps) |
| cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh |
| $(ACLOCAL_M4): $(am__aclocal_m4_deps) |
| cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh |
| $(am__aclocal_m4_deps): |
| clean-noinstLTLIBRARIES: |
| -test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES) |
| @list='$(noinst_LTLIBRARIES)'; \ |
| locs=`for p in $$list; do echo $$p; done | \ |
| sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \ |
| sort -u`; \ |
| test -z "$$locs" || { \ |
| echo rm -f $${locs}; \ |
| rm -f $${locs}; \ |
| } |
| libtrace.la: $(libtrace_la_OBJECTS) $(libtrace_la_DEPENDENCIES) $(EXTRA_libtrace_la_DEPENDENCIES) |
| $(AM_V_CCLD)$(LINK) $(libtrace_la_OBJECTS) $(libtrace_la_LIBADD) $(LIBS) |
| mostlyclean-compile: |
| -rm -f *.$(OBJEXT) |
| distclean-compile: |
| -rm -f *.tab.c |
| @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tr_context.Plo@am__quote@ |
| @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tr_dump.Plo@am__quote@ |
| @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tr_dump_state.Plo@am__quote@ |
| @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tr_screen.Plo@am__quote@ |
| @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tr_texture.Plo@am__quote@ |
| .c.o: |
| @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< |
| @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ |
| @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< |
| .c.obj: |
| @am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` |
| @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ |
| @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` |
| .c.lo: |
| @am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< |
| @am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ |
| @AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ |
| @am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< |
| mostlyclean-libtool: |
| -rm -f *.lo |
| clean-libtool: |
| -rm -rf .libs _libs |
| ID: $(am__tagged_files) |
| $(am__define_uniq_tagged_files); mkid -fID $$unique |
| tags: tags-am |
| TAGS: tags |
| tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) |
| set x; \ |
| here=`pwd`; \ |
| $(am__define_uniq_tagged_files); \ |
| shift; \ |
| if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ |
| test -n "$$unique" || unique=$$empty_fix; \ |
| if test $$# -gt 0; then \ |
| $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ |
| "$$@" $$unique; \ |
| else \ |
| $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ |
| $$unique; \ |
| fi; \ |
| fi |
| ctags: ctags-am |
| CTAGS: ctags |
| ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) |
| $(am__define_uniq_tagged_files); \ |
| test -z "$(CTAGS_ARGS)$$unique" \ |
| || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ |
| $$unique |
| GTAGS: |
| here=`$(am__cd) $(top_builddir) && pwd` \ |
| && $(am__cd) $(top_srcdir) \ |
| && gtags -i $(GTAGS_ARGS) "$$here" |
| cscopelist: cscopelist-am |
| cscopelist-am: $(am__tagged_files) |
| list='$(am__tagged_files)'; \ |
| case "$(srcdir)" in \ |
| [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ |
| *) sdir=$(subdir)/$(srcdir) ;; \ |
| esac; \ |
| for i in $$list; do \ |
| if test -f "$$i"; then \ |
| echo "$(subdir)/$$i"; \ |
| else \ |
| echo "$$sdir/$$i"; \ |
| fi; \ |
| done >> $(top_builddir)/cscope.files |
| distclean-tags: |
| -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags |
| distdir: $(DISTFILES) |
| @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ |
| topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ |
| list='$(DISTFILES)'; \ |
| dist_files=`for file in $$list; do echo $$file; done | \ |
| sed -e "s|^$$srcdirstrip/||;t" \ |
| -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ |
| case $$dist_files in \ |
| */*) $(MKDIR_P) `echo "$$dist_files" | \ |
| sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ |
| sort -u` ;; \ |
| esac; \ |
| for file in $$dist_files; do \ |
| if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ |
| if test -d $$d/$$file; then \ |
| dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ |
| if test -d "$(distdir)/$$file"; then \ |
| find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ |
| fi; \ |
| if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ |
| cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ |
| find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ |
| fi; \ |
| cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ |
| else \ |
| test -f "$(distdir)/$$file" \ |
| || cp -p $$d/$$file "$(distdir)/$$file" \ |
| || exit 1; \ |
| fi; \ |
| done |
| check-am: all-am |
| check: check-am |
| all-am: Makefile $(LTLIBRARIES) |
| installdirs: |
| install: install-am |
| install-exec: install-exec-am |
| install-data: install-data-am |
| uninstall: uninstall-am |
| install-am: all-am |
| @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am |
| installcheck: installcheck-am |
| install-strip: |
| if test -z '$(STRIP)'; then \ |
| $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ |
| install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ |
| install; \ |
| else \ |
| $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ |
| install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ |
| "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ |
| fi |
| mostlyclean-generic: |
| clean-generic: |
| distclean-generic: |
| -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) |
| -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) |
| maintainer-clean-generic: |
| @echo "This command is intended for maintainers to use" |
| @echo "it deletes files that may require special tools to rebuild." |
| clean: clean-am |
| clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \ |
| mostlyclean-am |
| distclean: distclean-am |
| -rm -rf ./$(DEPDIR) |
| -rm -f Makefile |
| distclean-am: clean-am distclean-compile distclean-generic \ |
| distclean-tags |
| dvi: dvi-am |
| dvi-am: |
| html: html-am |
| html-am: |
| info: info-am |
| info-am: |
| install-data-am: |
| install-dvi: install-dvi-am |
| install-dvi-am: |
| install-exec-am: |
| install-html: install-html-am |
| install-html-am: |
| install-info: install-info-am |
| install-info-am: |
| install-man: |
| install-pdf: install-pdf-am |
| install-pdf-am: |
| install-ps: install-ps-am |
| install-ps-am: |
| installcheck-am: |
| maintainer-clean: maintainer-clean-am |
| -rm -rf ./$(DEPDIR) |
| -rm -f Makefile |
| maintainer-clean-am: distclean-am maintainer-clean-generic |
| mostlyclean: mostlyclean-am |
| mostlyclean-am: mostlyclean-compile mostlyclean-generic \ |
| mostlyclean-libtool |
| pdf: pdf-am |
| pdf-am: |
| ps: ps-am |
| ps-am: |
| uninstall-am: |
| .MAKE: install-am install-strip |
| .PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \ |
| clean-libtool clean-noinstLTLIBRARIES cscopelist-am ctags \ |
| ctags-am distclean distclean-compile distclean-generic \ |
| distclean-libtool distclean-tags distdir dvi dvi-am html \ |
| html-am info info-am install install-am install-data \ |
| install-data-am install-dvi install-dvi-am install-exec \ |
| install-exec-am install-html install-html-am install-info \ |
| install-info-am install-man install-pdf install-pdf-am \ |
| install-ps install-ps-am install-strip installcheck \ |
| installcheck-am installdirs maintainer-clean \ |
| maintainer-clean-generic mostlyclean mostlyclean-compile \ |
| mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ |
| tags tags-am uninstall uninstall-am |
| # Tell versions [3.59,3.63) of GNU make to not export all variables. |
| # Otherwise a system limit (for SysV at least) may be exceeded. |
| .NOEXPORT: |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/README |
|---|
| 0,0 → 1,55 |
| TRACE PIPE DRIVER |
| = About = |
| This directory contains a Gallium3D trace debugger pipe driver. |
| It can traces all incoming calls. |
| = Usage = |
| == Tracing == |
| For tracing then do |
| GALLIUM_TRACE=tri.trace trivial/tri |
| which should create a tri.trace file, which is an XML file. You can view copying |
| trace.xsl to the same directory, and opening with a XSLT capable browser such as |
| Firefox or Internet Explorer. |
| For long traces you can use the |
| src/gallium/tools/trace/dump.py tri.trace | less -R |
| == Remote debugging == |
| For remote debugging see: |
| src/gallium/drivers/rbug/README |
| = Integrating = |
| You can integrate the trace pipe driver either inside the state tracker or the |
| target. The procedure on both cases is the same. Let's assume you have a |
| pipe_screen obtained by the usual means (variable and function names are just |
| for illustration purposes): |
| real_screen = real_screen_create(...); |
| The trace screen is then created by doing |
| trace_screen = trace_screen_create(real_screen); |
| You can then simply use trace_screen instead of real_screen. |
| You can create as many contexts you wish from trace_screen::context_create they |
| are automatically wrapped by trace_screen. |
| -- |
| Jose Fonseca <jfonseca@vmware.com> |
| Jakob Bornecrantz <jakob@vmware.com> |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/SConscript |
|---|
| 0,0 → 1,17 |
| Import('*') |
| env = env.Clone() |
| trace = env.ConvenienceLibrary( |
| target = 'trace', |
| source = [ |
| 'tr_context.c', |
| 'tr_dump.c', |
| 'tr_dump_state.c', |
| 'tr_screen.c', |
| 'tr_texture.c', |
| ]) |
| env.Alias('trace', trace) |
| Export('trace') |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_context.c |
|---|
| 0,0 → 1,1639 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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 "util/u_inlines.h" |
| #include "util/u_memory.h" |
| #include "util/u_simple_list.h" |
| #include "pipe/p_format.h" |
| #include "pipe/p_screen.h" |
| #include "tr_dump.h" |
| #include "tr_dump_state.h" |
| #include "tr_public.h" |
| #include "tr_screen.h" |
| #include "tr_texture.h" |
| #include "tr_context.h" |
| static INLINE struct pipe_resource * |
| trace_resource_unwrap(struct trace_context *tr_ctx, |
| struct pipe_resource *resource) |
| { |
| struct trace_resource *tr_res; |
| if(!resource) |
| return NULL; |
| tr_res = trace_resource(resource); |
| assert(tr_res->resource); |
| return tr_res->resource; |
| } |
| static INLINE struct pipe_surface * |
| trace_surface_unwrap(struct trace_context *tr_ctx, |
| struct pipe_surface *surface) |
| { |
| struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen); |
| struct trace_surface *tr_surf; |
| if(!surface) |
| return NULL; |
| assert(surface->texture); |
| if(!surface->texture) |
| return surface; |
| tr_surf = trace_surface(surface); |
| assert(tr_surf->surface); |
| assert(tr_surf->surface->texture->screen == tr_scr->screen); |
| (void) tr_scr; |
| return tr_surf->surface; |
| } |
| static INLINE void |
| trace_context_draw_vbo(struct pipe_context *_pipe, |
| const struct pipe_draw_info *info) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "draw_vbo"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(draw_info, info); |
| trace_dump_trace_flush(); |
| pipe->draw_vbo(pipe, info); |
| trace_dump_call_end(); |
| } |
| static INLINE struct pipe_query * |
| trace_context_create_query(struct pipe_context *_pipe, |
| unsigned query_type) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_query *result; |
| trace_dump_call_begin("pipe_context", "create_query"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, query_type); |
| result = pipe->create_query(pipe, query_type); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_destroy_query(struct pipe_context *_pipe, |
| struct pipe_query *query) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "destroy_query"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, query); |
| pipe->destroy_query(pipe, query); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_begin_query(struct pipe_context *_pipe, |
| struct pipe_query *query) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "begin_query"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, query); |
| pipe->begin_query(pipe, query); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_end_query(struct pipe_context *_pipe, |
| struct pipe_query *query) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "end_query"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, query); |
| pipe->end_query(pipe, query); |
| trace_dump_call_end(); |
| } |
| static INLINE boolean |
| trace_context_get_query_result(struct pipe_context *_pipe, |
| struct pipe_query *query, |
| boolean wait, |
| union pipe_query_result *presult) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| uint64_t result; |
| boolean _result; |
| trace_dump_call_begin("pipe_context", "get_query_result"); |
| trace_dump_arg(ptr, pipe); |
| _result = pipe->get_query_result(pipe, query, wait, presult); |
| /* XXX this depends on the query type */ |
| result = *((uint64_t*)presult); |
| trace_dump_arg(uint, result); |
| trace_dump_ret(bool, _result); |
| trace_dump_call_end(); |
| return _result; |
| } |
| static INLINE void * |
| trace_context_create_blend_state(struct pipe_context *_pipe, |
| const struct pipe_blend_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| void * result; |
| trace_dump_call_begin("pipe_context", "create_blend_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(blend_state, state); |
| result = pipe->create_blend_state(pipe, state); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_bind_blend_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "bind_blend_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->bind_blend_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_delete_blend_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "delete_blend_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->delete_blend_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void * |
| trace_context_create_sampler_state(struct pipe_context *_pipe, |
| const struct pipe_sampler_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| void * result; |
| trace_dump_call_begin("pipe_context", "create_sampler_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(sampler_state, state); |
| result = pipe->create_sampler_state(pipe, state); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_bind_sampler_states(struct pipe_context *_pipe, |
| unsigned shader, |
| unsigned start, |
| unsigned num_states, |
| void **states) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| /* remove this when we have pipe->bind_sampler_states(..., start, ...) */ |
| assert(start == 0); |
| switch (shader) { |
| case PIPE_SHADER_VERTEX: |
| trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states"); |
| break; |
| case PIPE_SHADER_GEOMETRY: |
| trace_dump_call_begin("pipe_context", "bind_geometry_sampler_states"); |
| break; |
| case PIPE_SHADER_FRAGMENT: |
| trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states"); |
| break; |
| default: |
| debug_error("Unexpected shader in trace_context_bind_sampler_states()"); |
| } |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, num_states); |
| trace_dump_arg_array(ptr, states, num_states); |
| switch (shader) { |
| case PIPE_SHADER_VERTEX: |
| pipe->bind_vertex_sampler_states(pipe, num_states, states); |
| break; |
| case PIPE_SHADER_GEOMETRY: |
| pipe->bind_geometry_sampler_states(pipe, num_states, states); |
| break; |
| case PIPE_SHADER_FRAGMENT: |
| pipe->bind_fragment_sampler_states(pipe, num_states, states); |
| break; |
| default: |
| debug_error("Unexpected shader in trace_context_bind_sampler_states()"); |
| } |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe, |
| unsigned num, |
| void **states) |
| { |
| trace_context_bind_sampler_states(_pipe, PIPE_SHADER_FRAGMENT, |
| 0, num, states); |
| } |
| static INLINE void |
| trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe, |
| unsigned num, |
| void **states) |
| { |
| trace_context_bind_sampler_states(_pipe, PIPE_SHADER_VERTEX, |
| 0, num, states); |
| } |
| static INLINE void |
| trace_context_bind_geometry_sampler_states(struct pipe_context *_pipe, |
| unsigned num, |
| void **states) |
| { |
| trace_context_bind_sampler_states(_pipe, PIPE_SHADER_GEOMETRY, |
| 0, num, states); |
| } |
| static INLINE void |
| trace_context_delete_sampler_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "delete_sampler_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->delete_sampler_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void * |
| trace_context_create_rasterizer_state(struct pipe_context *_pipe, |
| const struct pipe_rasterizer_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| void * result; |
| trace_dump_call_begin("pipe_context", "create_rasterizer_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(rasterizer_state, state); |
| result = pipe->create_rasterizer_state(pipe, state); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_bind_rasterizer_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "bind_rasterizer_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->bind_rasterizer_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_delete_rasterizer_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "delete_rasterizer_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->delete_rasterizer_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void * |
| trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe, |
| const struct pipe_depth_stencil_alpha_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| void * result; |
| trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state"); |
| result = pipe->create_depth_stencil_alpha_state(pipe, state); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(depth_stencil_alpha_state, state); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->bind_depth_stencil_alpha_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->delete_depth_stencil_alpha_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| #define TRACE_SHADER_STATE(shader_type) \ |
| static INLINE void * \ |
| trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \ |
| const struct pipe_shader_state *state) \ |
| { \ |
| struct trace_context *tr_ctx = trace_context(_pipe); \ |
| struct pipe_context *pipe = tr_ctx->pipe; \ |
| void * result; \ |
| trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \ |
| trace_dump_arg(ptr, pipe); \ |
| trace_dump_arg(shader_state, state); \ |
| result = pipe->create_##shader_type##_state(pipe, state); \ |
| trace_dump_ret(ptr, result); \ |
| trace_dump_call_end(); \ |
| return result; \ |
| } \ |
| \ |
| static INLINE void \ |
| trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \ |
| void *state) \ |
| { \ |
| struct trace_context *tr_ctx = trace_context(_pipe); \ |
| struct pipe_context *pipe = tr_ctx->pipe; \ |
| trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \ |
| trace_dump_arg(ptr, pipe); \ |
| trace_dump_arg(ptr, state); \ |
| pipe->bind_##shader_type##_state(pipe, state); \ |
| trace_dump_call_end(); \ |
| } \ |
| \ |
| static INLINE void \ |
| trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \ |
| void *state) \ |
| { \ |
| struct trace_context *tr_ctx = trace_context(_pipe); \ |
| struct pipe_context *pipe = tr_ctx->pipe; \ |
| trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \ |
| trace_dump_arg(ptr, pipe); \ |
| trace_dump_arg(ptr, state); \ |
| pipe->delete_##shader_type##_state(pipe, state); \ |
| trace_dump_call_end(); \ |
| } |
| TRACE_SHADER_STATE(fs) |
| TRACE_SHADER_STATE(vs) |
| TRACE_SHADER_STATE(gs) |
| #undef TRACE_SHADER_STATE |
| static INLINE void * |
| trace_context_create_vertex_elements_state(struct pipe_context *_pipe, |
| unsigned num_elements, |
| const struct pipe_vertex_element *elements) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| void * result; |
| trace_dump_call_begin("pipe_context", "create_vertex_elements_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, num_elements); |
| trace_dump_arg_begin("elements"); |
| trace_dump_struct_array(vertex_element, elements, num_elements); |
| trace_dump_arg_end(); |
| result = pipe->create_vertex_elements_state(pipe, num_elements, elements); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_bind_vertex_elements_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "bind_vertex_elements_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->bind_vertex_elements_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_delete_vertex_elements_state(struct pipe_context *_pipe, |
| void *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "delete_vertex_elements_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, state); |
| pipe->delete_vertex_elements_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_blend_color(struct pipe_context *_pipe, |
| const struct pipe_blend_color *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_blend_color"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(blend_color, state); |
| pipe->set_blend_color(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_stencil_ref(struct pipe_context *_pipe, |
| const struct pipe_stencil_ref *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_stencil_ref"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(stencil_ref, state); |
| pipe->set_stencil_ref(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_clip_state(struct pipe_context *_pipe, |
| const struct pipe_clip_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_clip_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(clip_state, state); |
| pipe->set_clip_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_sample_mask(struct pipe_context *_pipe, |
| unsigned sample_mask) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_sample_mask"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, sample_mask); |
| pipe->set_sample_mask(pipe, sample_mask); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_constant_buffer(struct pipe_context *_pipe, |
| uint shader, uint index, |
| struct pipe_constant_buffer *constant_buffer) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_constant_buffer cb; |
| if (constant_buffer) { |
| cb = *constant_buffer; |
| cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer); |
| constant_buffer = &cb; |
| } |
| trace_dump_call_begin("pipe_context", "set_constant_buffer"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, shader); |
| trace_dump_arg(uint, index); |
| trace_dump_arg(constant_buffer, constant_buffer); |
| pipe->set_constant_buffer(pipe, shader, index, constant_buffer); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_framebuffer_state(struct pipe_context *_pipe, |
| const struct pipe_framebuffer_state *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_framebuffer_state unwrapped_state; |
| unsigned i; |
| /* Unwrap the input state */ |
| memcpy(&unwrapped_state, state, sizeof(unwrapped_state)); |
| for(i = 0; i < state->nr_cbufs; ++i) |
| unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]); |
| for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i) |
| unwrapped_state.cbufs[i] = NULL; |
| unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf); |
| state = &unwrapped_state; |
| trace_dump_call_begin("pipe_context", "set_framebuffer_state"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(framebuffer_state, state); |
| pipe->set_framebuffer_state(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_polygon_stipple(struct pipe_context *_pipe, |
| const struct pipe_poly_stipple *state) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_polygon_stipple"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(poly_stipple, state); |
| pipe->set_polygon_stipple(pipe, state); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_scissor_states(struct pipe_context *_pipe, |
| unsigned start_slot, |
| unsigned num_scissors, |
| const struct pipe_scissor_state *states) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_scissor_states"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, start_slot); |
| trace_dump_arg(uint, num_scissors); |
| trace_dump_arg(scissor_state, states); |
| pipe->set_scissor_states(pipe, start_slot, num_scissors, states); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_viewport_states(struct pipe_context *_pipe, |
| unsigned start_slot, |
| unsigned num_viewports, |
| const struct pipe_viewport_state *states) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_viewport_states"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, start_slot); |
| trace_dump_arg(uint, num_viewports); |
| trace_dump_arg(viewport_state, states); |
| pipe->set_viewport_states(pipe, start_slot, num_viewports, states); |
| trace_dump_call_end(); |
| } |
| static struct pipe_sampler_view * |
| trace_context_create_sampler_view(struct pipe_context *_pipe, |
| struct pipe_resource *_resource, |
| const struct pipe_sampler_view *templ) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_resource *resource = tr_res->resource; |
| struct pipe_sampler_view *result; |
| struct trace_sampler_view *tr_view; |
| trace_dump_call_begin("pipe_context", "create_sampler_view"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, resource); |
| trace_dump_arg_begin("templ"); |
| trace_dump_sampler_view_template(templ, resource->target); |
| trace_dump_arg_end(); |
| result = pipe->create_sampler_view(pipe, resource, templ); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| /* |
| * Wrap pipe_sampler_view |
| */ |
| tr_view = CALLOC_STRUCT(trace_sampler_view); |
| tr_view->base = *templ; |
| tr_view->base.reference.count = 1; |
| tr_view->base.texture = NULL; |
| pipe_resource_reference(&tr_view->base.texture, _resource); |
| tr_view->base.context = _pipe; |
| tr_view->sampler_view = result; |
| result = &tr_view->base; |
| return result; |
| } |
| static void |
| trace_context_sampler_view_destroy(struct pipe_context *_pipe, |
| struct pipe_sampler_view *_view) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct trace_sampler_view *tr_view = trace_sampler_view(_view); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_sampler_view *view = tr_view->sampler_view; |
| assert(_view->context == _pipe); |
| trace_dump_call_begin("pipe_context", "sampler_view_destroy"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, view); |
| pipe_sampler_view_reference(&tr_view->sampler_view, NULL); |
| trace_dump_call_end(); |
| pipe_resource_reference(&_view->texture, NULL); |
| FREE(_view); |
| } |
| /******************************************************************** |
| * surface |
| */ |
| static struct pipe_surface * |
| trace_context_create_surface(struct pipe_context *_pipe, |
| struct pipe_resource *_resource, |
| const struct pipe_surface *surf_tmpl) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_resource *resource = tr_res->resource; |
| struct pipe_surface *result = NULL; |
| trace_dump_call_begin("pipe_context", "create_surface"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, resource); |
| trace_dump_arg_begin("surf_tmpl"); |
| trace_dump_surface_template(surf_tmpl, resource->target); |
| trace_dump_arg_end(); |
| result = pipe->create_surface(pipe, resource, surf_tmpl); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| result = trace_surf_create(tr_ctx, tr_res, result); |
| return result; |
| } |
| static void |
| trace_context_surface_destroy(struct pipe_context *_pipe, |
| struct pipe_surface *_surface) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct trace_surface *tr_surf = trace_surface(_surface); |
| struct pipe_surface *surface = tr_surf->surface; |
| trace_dump_call_begin("pipe_context", "surface_destroy"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, surface); |
| trace_dump_call_end(); |
| trace_surf_destroy(tr_surf); |
| } |
| static INLINE void |
| trace_context_set_sampler_views(struct pipe_context *_pipe, |
| unsigned shader, |
| unsigned start, |
| unsigned num, |
| struct pipe_sampler_view **views) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct trace_sampler_view *tr_view; |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS]; |
| unsigned i; |
| /* remove this when we have pipe->set_sampler_views(..., start, ...) */ |
| assert(start == 0); |
| for(i = 0; i < num; ++i) { |
| tr_view = trace_sampler_view(views[i]); |
| unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL; |
| } |
| views = unwrapped_views; |
| switch (shader) { |
| case PIPE_SHADER_VERTEX: |
| trace_dump_call_begin("pipe_context", "set_vertex_sampler_views"); |
| break; |
| case PIPE_SHADER_GEOMETRY: |
| trace_dump_call_begin("pipe_context", "set_geometry_sampler_views"); |
| break; |
| case PIPE_SHADER_FRAGMENT: |
| trace_dump_call_begin("pipe_context", "set_fragment_sampler_views"); |
| break; |
| default: |
| debug_error("Unexpected shader in trace_context_set_sampler_views()"); |
| } |
| trace_dump_arg(ptr, pipe); |
| /*trace_dump_arg(uint, shader);*/ |
| trace_dump_arg(uint, num); |
| trace_dump_arg_array(ptr, views, num); |
| switch (shader) { |
| case PIPE_SHADER_VERTEX: |
| pipe->set_vertex_sampler_views(pipe, num, views); |
| break; |
| case PIPE_SHADER_GEOMETRY: |
| pipe->set_geometry_sampler_views(pipe, num, views); |
| break; |
| case PIPE_SHADER_FRAGMENT: |
| pipe->set_fragment_sampler_views(pipe, num, views); |
| break; |
| default: |
| debug_error("Unexpected shader in trace_context_set_sampler_views()"); |
| } |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_fragment_sampler_views(struct pipe_context *_pipe, |
| unsigned num, |
| struct pipe_sampler_view **views) |
| { |
| trace_context_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 0, num, views); |
| } |
| static INLINE void |
| trace_context_set_vertex_sampler_views(struct pipe_context *_pipe, |
| unsigned num, |
| struct pipe_sampler_view **views) |
| { |
| trace_context_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 0, num, views); |
| } |
| static INLINE void |
| trace_context_set_geometry_sampler_views(struct pipe_context *_pipe, |
| unsigned num, |
| struct pipe_sampler_view **views) |
| { |
| trace_context_set_sampler_views(_pipe, PIPE_SHADER_GEOMETRY, 0, num, views); |
| } |
| static INLINE void |
| trace_context_set_vertex_buffers(struct pipe_context *_pipe, |
| unsigned start_slot, unsigned num_buffers, |
| const struct pipe_vertex_buffer *buffers) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| unsigned i; |
| trace_dump_call_begin("pipe_context", "set_vertex_buffers"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, start_slot); |
| trace_dump_arg(uint, num_buffers); |
| trace_dump_arg_begin("buffers"); |
| trace_dump_struct_array(vertex_buffer, buffers, num_buffers); |
| trace_dump_arg_end(); |
| if (buffers) { |
| struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers)); |
| memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers)); |
| for (i = 0; i < num_buffers; i++) |
| _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer); |
| pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers); |
| FREE(_buffers); |
| } else { |
| pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL); |
| } |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_index_buffer(struct pipe_context *_pipe, |
| const struct pipe_index_buffer *ib) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_index_buffer"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(index_buffer, ib); |
| if (ib) { |
| struct pipe_index_buffer _ib; |
| _ib = *ib; |
| _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer); |
| pipe->set_index_buffer(pipe, &_ib); |
| } else { |
| pipe->set_index_buffer(pipe, NULL); |
| } |
| trace_dump_call_end(); |
| } |
| static INLINE struct pipe_stream_output_target * |
| trace_context_create_stream_output_target(struct pipe_context *_pipe, |
| struct pipe_resource *res, |
| unsigned buffer_offset, |
| unsigned buffer_size) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_stream_output_target *result; |
| res = trace_resource_unwrap(tr_ctx, res); |
| trace_dump_call_begin("pipe_context", "create_stream_output_target"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, res); |
| trace_dump_arg(uint, buffer_offset); |
| trace_dump_arg(uint, buffer_size); |
| result = pipe->create_stream_output_target(pipe, |
| res, buffer_offset, buffer_size); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static INLINE void |
| trace_context_stream_output_target_destroy( |
| struct pipe_context *_pipe, |
| struct pipe_stream_output_target *target) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "stream_output_target_destroy"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, target); |
| pipe->stream_output_target_destroy(pipe, target); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_set_stream_output_targets(struct pipe_context *_pipe, |
| unsigned num_targets, |
| struct pipe_stream_output_target **tgs, |
| unsigned append_bitmask) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "set_stream_output_targets"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, num_targets); |
| trace_dump_arg_array(ptr, tgs, num_targets); |
| trace_dump_arg(uint, append_bitmask); |
| pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_resource_copy_region(struct pipe_context *_pipe, |
| struct pipe_resource *dst, |
| unsigned dst_level, |
| unsigned dstx, unsigned dsty, unsigned dstz, |
| struct pipe_resource *src, |
| unsigned src_level, |
| const struct pipe_box *src_box) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| dst = trace_resource_unwrap(tr_ctx, dst); |
| src = trace_resource_unwrap(tr_ctx, src); |
| trace_dump_call_begin("pipe_context", "resource_copy_region"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, dst); |
| trace_dump_arg(uint, dst_level); |
| trace_dump_arg(uint, dstx); |
| trace_dump_arg(uint, dsty); |
| trace_dump_arg(uint, dstz); |
| trace_dump_arg(ptr, src); |
| trace_dump_arg(uint, src_level); |
| trace_dump_arg(box, src_box); |
| pipe->resource_copy_region(pipe, |
| dst, dst_level, dstx, dsty, dstz, |
| src, src_level, src_box); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_blit(struct pipe_context *_pipe, |
| const struct pipe_blit_info *_info) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| struct pipe_blit_info info = *_info; |
| info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource); |
| info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource); |
| trace_dump_call_begin("pipe_context", "blit"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(blit_info, _info); |
| pipe->blit(pipe, &info); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_clear(struct pipe_context *_pipe, |
| unsigned buffers, |
| const union pipe_color_union *color, |
| double depth, |
| unsigned stencil) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "clear"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, buffers); |
| trace_dump_arg_begin("color"); |
| if (color) |
| trace_dump_array(float, color->f, 4); |
| else |
| trace_dump_null(); |
| trace_dump_arg_end(); |
| trace_dump_arg(float, depth); |
| trace_dump_arg(uint, stencil); |
| pipe->clear(pipe, buffers, color, depth, stencil); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_clear_render_target(struct pipe_context *_pipe, |
| struct pipe_surface *dst, |
| const union pipe_color_union *color, |
| unsigned dstx, unsigned dsty, |
| unsigned width, unsigned height) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| dst = trace_surface_unwrap(tr_ctx, dst); |
| trace_dump_call_begin("pipe_context", "clear_render_target"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, dst); |
| trace_dump_arg_array(float, color->f, 4); |
| trace_dump_arg(uint, dstx); |
| trace_dump_arg(uint, dsty); |
| trace_dump_arg(uint, width); |
| trace_dump_arg(uint, height); |
| pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_clear_depth_stencil(struct pipe_context *_pipe, |
| struct pipe_surface *dst, |
| unsigned clear_flags, |
| double depth, |
| unsigned stencil, |
| unsigned dstx, unsigned dsty, |
| unsigned width, unsigned height) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| dst = trace_surface_unwrap(tr_ctx, dst); |
| trace_dump_call_begin("pipe_context", "clear_depth_stencil"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(ptr, dst); |
| trace_dump_arg(uint, clear_flags); |
| trace_dump_arg(float, depth); |
| trace_dump_arg(uint, stencil); |
| trace_dump_arg(uint, dstx); |
| trace_dump_arg(uint, dsty); |
| trace_dump_arg(uint, width); |
| trace_dump_arg(uint, height); |
| pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil, |
| dstx, dsty, width, height); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_flush(struct pipe_context *_pipe, |
| struct pipe_fence_handle **fence, |
| unsigned flags) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "flush"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_arg(uint, flags); |
| pipe->flush(pipe, fence, flags); |
| if(fence) |
| trace_dump_ret(ptr, *fence); |
| trace_dump_call_end(); |
| } |
| static INLINE void |
| trace_context_destroy(struct pipe_context *_pipe) |
| { |
| struct trace_context *tr_ctx = trace_context(_pipe); |
| struct pipe_context *pipe = tr_ctx->pipe; |
| trace_dump_call_begin("pipe_context", "destroy"); |
| trace_dump_arg(ptr, pipe); |
| trace_dump_call_end(); |
| pipe->destroy(pipe); |
| FREE(tr_ctx); |
| } |
| /******************************************************************** |
| * transfer |
| */ |
| static void * |
| trace_context_transfer_map(struct pipe_context *_context, |
| struct pipe_resource *_resource, |
| unsigned level, |
| unsigned usage, |
| const struct pipe_box *box, |
| struct pipe_transfer **transfer) |
| { |
| struct trace_context *tr_context = trace_context(_context); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_context *context = tr_context->pipe; |
| struct pipe_resource *texture = tr_res->resource; |
| struct pipe_transfer *result = NULL; |
| void *map; |
| assert(texture->screen == context->screen); |
| /* |
| * Map and transfers can't be serialized so we convert all write transfers |
| * to transfer_inline_write and ignore read transfers. |
| */ |
| map = context->transfer_map(context, texture, level, usage, box, &result); |
| if (!map) |
| return NULL; |
| *transfer = trace_transfer_create(tr_context, tr_res, result); |
| if (map) { |
| if(usage & PIPE_TRANSFER_WRITE) { |
| trace_transfer(*transfer)->map = map; |
| } |
| } |
| return *transfer ? map : NULL; |
| } |
| static void |
| trace_context_transfer_flush_region( struct pipe_context *_context, |
| struct pipe_transfer *_transfer, |
| const struct pipe_box *box) |
| { |
| struct trace_context *tr_context = trace_context(_context); |
| struct trace_transfer *tr_transfer = trace_transfer(_transfer); |
| struct pipe_context *context = tr_context->pipe; |
| struct pipe_transfer *transfer = tr_transfer->transfer; |
| context->transfer_flush_region(context, |
| transfer, |
| box); |
| } |
| static void |
| trace_context_transfer_unmap(struct pipe_context *_context, |
| struct pipe_transfer *_transfer) |
| { |
| struct trace_context *tr_ctx = trace_context(_context); |
| struct trace_transfer *tr_trans = trace_transfer(_transfer); |
| struct pipe_context *context = tr_ctx->pipe; |
| struct pipe_transfer *transfer = tr_trans->transfer; |
| if(tr_trans->map) { |
| /* |
| * Fake a transfer_inline_write |
| */ |
| struct pipe_resource *resource = transfer->resource; |
| unsigned level = transfer->level; |
| unsigned usage = transfer->usage; |
| const struct pipe_box *box = &transfer->box; |
| unsigned stride = transfer->stride; |
| unsigned layer_stride = transfer->layer_stride; |
| trace_dump_call_begin("pipe_context", "transfer_inline_write"); |
| trace_dump_arg(ptr, context); |
| trace_dump_arg(ptr, resource); |
| trace_dump_arg(uint, level); |
| trace_dump_arg(uint, usage); |
| trace_dump_arg(box, box); |
| trace_dump_arg_begin("data"); |
| trace_dump_box_bytes(tr_trans->map, |
| resource, |
| box, |
| stride, |
| layer_stride); |
| trace_dump_arg_end(); |
| trace_dump_arg(uint, stride); |
| trace_dump_arg(uint, layer_stride); |
| trace_dump_call_end(); |
| tr_trans->map = NULL; |
| } |
| context->transfer_unmap(context, transfer); |
| trace_transfer_destroy(tr_ctx, tr_trans); |
| } |
| static void |
| trace_context_transfer_inline_write(struct pipe_context *_context, |
| struct pipe_resource *_resource, |
| unsigned level, |
| unsigned usage, |
| const struct pipe_box *box, |
| const void *data, |
| unsigned stride, |
| unsigned layer_stride) |
| { |
| struct trace_context *tr_context = trace_context(_context); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_context *context = tr_context->pipe; |
| struct pipe_resource *resource = tr_res->resource; |
| assert(resource->screen == context->screen); |
| trace_dump_call_begin("pipe_context", "transfer_inline_write"); |
| trace_dump_arg(ptr, context); |
| trace_dump_arg(ptr, resource); |
| trace_dump_arg(uint, level); |
| trace_dump_arg(uint, usage); |
| trace_dump_arg(box, box); |
| trace_dump_arg_begin("data"); |
| trace_dump_box_bytes(data, |
| resource, |
| box, |
| stride, |
| layer_stride); |
| trace_dump_arg_end(); |
| trace_dump_arg(uint, stride); |
| trace_dump_arg(uint, layer_stride); |
| trace_dump_call_end(); |
| context->transfer_inline_write(context, resource, |
| level, usage, box, data, stride, layer_stride); |
| } |
| static void trace_context_render_condition(struct pipe_context *_context, |
| struct pipe_query *query, |
| boolean condition, |
| uint mode) |
| { |
| struct trace_context *tr_context = trace_context(_context); |
| struct pipe_context *context = tr_context->pipe; |
| trace_dump_call_begin("pipe_context", "render_condition"); |
| trace_dump_arg(ptr, context); |
| trace_dump_arg(ptr, query); |
| trace_dump_arg(bool, condition); |
| trace_dump_arg(uint, mode); |
| trace_dump_call_end(); |
| context->render_condition(context, query, condition, mode); |
| } |
| static void trace_context_texture_barrier(struct pipe_context *_context) |
| { |
| struct trace_context *tr_context = trace_context(_context); |
| struct pipe_context *context = tr_context->pipe; |
| trace_dump_call_begin("pipe_context", "texture_barrier"); |
| trace_dump_arg(ptr, context); |
| trace_dump_call_end(); |
| context->texture_barrier(context); |
| } |
| static const struct debug_named_value rbug_blocker_flags[] = { |
| {"before", 1, NULL}, |
| {"after", 2, NULL}, |
| DEBUG_NAMED_VALUE_END |
| }; |
| struct pipe_context * |
| trace_context_create(struct trace_screen *tr_scr, |
| struct pipe_context *pipe) |
| { |
| struct trace_context *tr_ctx; |
| if(!pipe) |
| goto error1; |
| if(!trace_enabled()) |
| goto error1; |
| tr_ctx = CALLOC_STRUCT(trace_context); |
| if(!tr_ctx) |
| goto error1; |
| tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */ |
| tr_ctx->base.screen = &tr_scr->base; |
| tr_ctx->base.destroy = trace_context_destroy; |
| #define TR_CTX_INIT(_member) \ |
| tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL |
| TR_CTX_INIT(draw_vbo); |
| TR_CTX_INIT(render_condition); |
| TR_CTX_INIT(create_query); |
| TR_CTX_INIT(destroy_query); |
| TR_CTX_INIT(begin_query); |
| TR_CTX_INIT(end_query); |
| TR_CTX_INIT(get_query_result); |
| TR_CTX_INIT(create_blend_state); |
| TR_CTX_INIT(bind_blend_state); |
| TR_CTX_INIT(delete_blend_state); |
| TR_CTX_INIT(create_sampler_state); |
| TR_CTX_INIT(bind_fragment_sampler_states); |
| TR_CTX_INIT(bind_vertex_sampler_states); |
| TR_CTX_INIT(bind_geometry_sampler_states); |
| TR_CTX_INIT(delete_sampler_state); |
| TR_CTX_INIT(create_rasterizer_state); |
| TR_CTX_INIT(bind_rasterizer_state); |
| TR_CTX_INIT(delete_rasterizer_state); |
| TR_CTX_INIT(create_depth_stencil_alpha_state); |
| TR_CTX_INIT(bind_depth_stencil_alpha_state); |
| TR_CTX_INIT(delete_depth_stencil_alpha_state); |
| TR_CTX_INIT(create_fs_state); |
| TR_CTX_INIT(bind_fs_state); |
| TR_CTX_INIT(delete_fs_state); |
| TR_CTX_INIT(create_vs_state); |
| TR_CTX_INIT(bind_vs_state); |
| TR_CTX_INIT(delete_vs_state); |
| TR_CTX_INIT(create_gs_state); |
| TR_CTX_INIT(bind_gs_state); |
| TR_CTX_INIT(delete_gs_state); |
| TR_CTX_INIT(create_vertex_elements_state); |
| TR_CTX_INIT(bind_vertex_elements_state); |
| TR_CTX_INIT(delete_vertex_elements_state); |
| TR_CTX_INIT(set_blend_color); |
| TR_CTX_INIT(set_stencil_ref); |
| TR_CTX_INIT(set_clip_state); |
| TR_CTX_INIT(set_sample_mask); |
| TR_CTX_INIT(set_constant_buffer); |
| TR_CTX_INIT(set_framebuffer_state); |
| TR_CTX_INIT(set_polygon_stipple); |
| TR_CTX_INIT(set_scissor_states); |
| TR_CTX_INIT(set_viewport_states); |
| TR_CTX_INIT(set_fragment_sampler_views); |
| TR_CTX_INIT(set_vertex_sampler_views); |
| TR_CTX_INIT(set_geometry_sampler_views); |
| TR_CTX_INIT(create_sampler_view); |
| TR_CTX_INIT(sampler_view_destroy); |
| TR_CTX_INIT(create_surface); |
| TR_CTX_INIT(surface_destroy); |
| TR_CTX_INIT(set_vertex_buffers); |
| TR_CTX_INIT(set_index_buffer); |
| TR_CTX_INIT(create_stream_output_target); |
| TR_CTX_INIT(stream_output_target_destroy); |
| TR_CTX_INIT(set_stream_output_targets); |
| TR_CTX_INIT(resource_copy_region); |
| TR_CTX_INIT(blit); |
| TR_CTX_INIT(clear); |
| TR_CTX_INIT(clear_render_target); |
| TR_CTX_INIT(clear_depth_stencil); |
| TR_CTX_INIT(flush); |
| TR_CTX_INIT(texture_barrier); |
| TR_CTX_INIT(transfer_map); |
| TR_CTX_INIT(transfer_unmap); |
| TR_CTX_INIT(transfer_flush_region); |
| TR_CTX_INIT(transfer_inline_write); |
| #undef TR_CTX_INIT |
| tr_ctx->pipe = pipe; |
| return &tr_ctx->base; |
| error1: |
| return pipe; |
| } |
| /** |
| * Sanity checker: check that the given context really is a |
| * trace context (and not the wrapped driver's context). |
| */ |
| void |
| trace_context_check(const struct pipe_context *pipe) |
| { |
| struct trace_context *tr_ctx = (struct trace_context *) pipe; |
| assert(tr_ctx->base.destroy == trace_context_destroy); |
| } |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_context.h |
|---|
| 0,0 → 1,77 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| #ifndef TR_CONTEXT_H_ |
| #define TR_CONTEXT_H_ |
| #include "pipe/p_compiler.h" |
| #include "util/u_debug.h" |
| #include "pipe/p_context.h" |
| #include "tr_screen.h" |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| struct trace_screen; |
| struct trace_context |
| { |
| struct pipe_context base; |
| struct pipe_context *pipe; |
| }; |
| void |
| trace_context_check(const struct pipe_context *pipe); |
| static INLINE struct trace_context * |
| trace_context(struct pipe_context *pipe) |
| { |
| assert(pipe); |
| #ifdef DEBUG |
| trace_context_check(pipe); |
| #endif |
| return (struct trace_context *)pipe; |
| } |
| struct pipe_context * |
| trace_context_create(struct trace_screen *tr_scr, |
| struct pipe_context *pipe); |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* TR_CONTEXT_H_ */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_dump.c |
|---|
| 0,0 → 1,666 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| /** |
| * @file |
| * Trace dumping functions. |
| * |
| * For now we just use standard XML for dumping the trace calls, as this is |
| * simple to write, parse, and visually inspect, but the actual representation |
| * is abstracted out of this file, so that we can switch to a binary |
| * representation if/when it becomes justified. |
| * |
| * @author Jose Fonseca <jrfonseca@tungstengraphics.com> |
| */ |
| #include "pipe/p_config.h" |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include "pipe/p_compiler.h" |
| #include "os/os_thread.h" |
| #include "os/os_time.h" |
| #include "util/u_debug.h" |
| #include "util/u_memory.h" |
| #include "util/u_string.h" |
| #include "util/u_math.h" |
| #include "util/u_format.h" |
| #include "tr_dump.h" |
| #include "tr_screen.h" |
| #include "tr_texture.h" |
| static boolean close_stream = FALSE; |
| static FILE *stream = NULL; |
| pipe_static_mutex(call_mutex); |
| static long unsigned call_no = 0; |
| static boolean dumping = FALSE; |
| static INLINE void |
| trace_dump_write(const char *buf, size_t size) |
| { |
| if (stream) { |
| fwrite(buf, size, 1, stream); |
| } |
| } |
| static INLINE void |
| trace_dump_writes(const char *s) |
| { |
| trace_dump_write(s, strlen(s)); |
| } |
| static INLINE void |
| trace_dump_writef(const char *format, ...) |
| { |
| static char buf[1024]; |
| unsigned len; |
| va_list ap; |
| va_start(ap, format); |
| len = util_vsnprintf(buf, sizeof(buf), format, ap); |
| va_end(ap); |
| trace_dump_write(buf, len); |
| } |
| static INLINE void |
| trace_dump_escape(const char *str) |
| { |
| const unsigned char *p = (const unsigned char *)str; |
| unsigned char c; |
| while((c = *p++) != 0) { |
| if(c == '<') |
| trace_dump_writes("<"); |
| else if(c == '>') |
| trace_dump_writes(">"); |
| else if(c == '&') |
| trace_dump_writes("&"); |
| else if(c == '\'') |
| trace_dump_writes("'"); |
| else if(c == '\"') |
| trace_dump_writes("""); |
| else if(c >= 0x20 && c <= 0x7e) |
| trace_dump_writef("%c", c); |
| else |
| trace_dump_writef("&#%u;", c); |
| } |
| } |
| static INLINE void |
| trace_dump_indent(unsigned level) |
| { |
| unsigned i; |
| for(i = 0; i < level; ++i) |
| trace_dump_writes("\t"); |
| } |
| static INLINE void |
| trace_dump_newline(void) |
| { |
| trace_dump_writes("\n"); |
| } |
| static INLINE void |
| trace_dump_tag(const char *name) |
| { |
| trace_dump_writes("<"); |
| trace_dump_writes(name); |
| trace_dump_writes("/>"); |
| } |
| static INLINE void |
| trace_dump_tag_begin(const char *name) |
| { |
| trace_dump_writes("<"); |
| trace_dump_writes(name); |
| trace_dump_writes(">"); |
| } |
| static INLINE void |
| trace_dump_tag_begin1(const char *name, |
| const char *attr1, const char *value1) |
| { |
| trace_dump_writes("<"); |
| trace_dump_writes(name); |
| trace_dump_writes(" "); |
| trace_dump_writes(attr1); |
| trace_dump_writes("='"); |
| trace_dump_escape(value1); |
| trace_dump_writes("'>"); |
| } |
| static INLINE void |
| trace_dump_tag_begin2(const char *name, |
| const char *attr1, const char *value1, |
| const char *attr2, const char *value2) |
| { |
| trace_dump_writes("<"); |
| trace_dump_writes(name); |
| trace_dump_writes(" "); |
| trace_dump_writes(attr1); |
| trace_dump_writes("=\'"); |
| trace_dump_escape(value1); |
| trace_dump_writes("\' "); |
| trace_dump_writes(attr2); |
| trace_dump_writes("=\'"); |
| trace_dump_escape(value2); |
| trace_dump_writes("\'>"); |
| } |
| static INLINE void |
| trace_dump_tag_begin3(const char *name, |
| const char *attr1, const char *value1, |
| const char *attr2, const char *value2, |
| const char *attr3, const char *value3) |
| { |
| trace_dump_writes("<"); |
| trace_dump_writes(name); |
| trace_dump_writes(" "); |
| trace_dump_writes(attr1); |
| trace_dump_writes("=\'"); |
| trace_dump_escape(value1); |
| trace_dump_writes("\' "); |
| trace_dump_writes(attr2); |
| trace_dump_writes("=\'"); |
| trace_dump_escape(value2); |
| trace_dump_writes("\' "); |
| trace_dump_writes(attr3); |
| trace_dump_writes("=\'"); |
| trace_dump_escape(value3); |
| trace_dump_writes("\'>"); |
| } |
| static INLINE void |
| trace_dump_tag_end(const char *name) |
| { |
| trace_dump_writes("</"); |
| trace_dump_writes(name); |
| trace_dump_writes(">"); |
| } |
| void |
| trace_dump_trace_flush(void) |
| { |
| if(stream) { |
| fflush(stream); |
| } |
| } |
| static void |
| trace_dump_trace_close(void) |
| { |
| if(stream) { |
| trace_dump_writes("</trace>\n"); |
| if (close_stream) { |
| fclose(stream); |
| close_stream = FALSE; |
| stream = NULL; |
| } |
| call_no = 0; |
| } |
| } |
| static void |
| trace_dump_call_time(int64_t time) |
| { |
| if (stream) { |
| trace_dump_indent(2); |
| trace_dump_tag_begin("time"); |
| trace_dump_int(time); |
| trace_dump_tag_end("time"); |
| trace_dump_newline(); |
| } |
| } |
| boolean |
| trace_dump_trace_begin(void) |
| { |
| const char *filename; |
| filename = debug_get_option("GALLIUM_TRACE", NULL); |
| if(!filename) |
| return FALSE; |
| if(!stream) { |
| if (strcmp(filename, "stderr") == 0) { |
| close_stream = FALSE; |
| stream = stderr; |
| } |
| else if (strcmp(filename, "stdout") == 0) { |
| close_stream = FALSE; |
| stream = stdout; |
| } |
| else { |
| close_stream = TRUE; |
| stream = fopen(filename, "wt"); |
| if (!stream) |
| return FALSE; |
| } |
| trace_dump_writes("<?xml version='1.0' encoding='UTF-8'?>\n"); |
| trace_dump_writes("<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n"); |
| trace_dump_writes("<trace version='0.1'>\n"); |
| /* Many applications don't exit cleanly, others may create and destroy a |
| * screen multiple times, so we only write </trace> tag and close at exit |
| * time. |
| */ |
| atexit(trace_dump_trace_close); |
| } |
| return TRUE; |
| } |
| boolean trace_dump_trace_enabled(void) |
| { |
| return stream ? TRUE : FALSE; |
| } |
| /* |
| * Call lock |
| */ |
| void trace_dump_call_lock(void) |
| { |
| pipe_mutex_lock(call_mutex); |
| } |
| void trace_dump_call_unlock(void) |
| { |
| pipe_mutex_unlock(call_mutex); |
| } |
| /* |
| * Dumping control |
| */ |
| void trace_dumping_start_locked(void) |
| { |
| dumping = TRUE; |
| } |
| void trace_dumping_stop_locked(void) |
| { |
| dumping = FALSE; |
| } |
| boolean trace_dumping_enabled_locked(void) |
| { |
| return dumping; |
| } |
| void trace_dumping_start(void) |
| { |
| pipe_mutex_lock(call_mutex); |
| trace_dumping_start_locked(); |
| pipe_mutex_unlock(call_mutex); |
| } |
| void trace_dumping_stop(void) |
| { |
| pipe_mutex_lock(call_mutex); |
| trace_dumping_stop_locked(); |
| pipe_mutex_unlock(call_mutex); |
| } |
| boolean trace_dumping_enabled(void) |
| { |
| boolean ret; |
| pipe_mutex_lock(call_mutex); |
| ret = trace_dumping_enabled_locked(); |
| pipe_mutex_unlock(call_mutex); |
| return ret; |
| } |
| /* |
| * Dump functions |
| */ |
| static int64_t call_start_time = 0; |
| void trace_dump_call_begin_locked(const char *klass, const char *method) |
| { |
| if (!dumping) |
| return; |
| ++call_no; |
| trace_dump_indent(1); |
| trace_dump_writes("<call no=\'"); |
| trace_dump_writef("%lu", call_no); |
| trace_dump_writes("\' class=\'"); |
| trace_dump_escape(klass); |
| trace_dump_writes("\' method=\'"); |
| trace_dump_escape(method); |
| trace_dump_writes("\'>"); |
| trace_dump_newline(); |
| call_start_time = os_time_get(); |
| } |
| void trace_dump_call_end_locked(void) |
| { |
| int64_t call_end_time; |
| if (!dumping) |
| return; |
| call_end_time = os_time_get(); |
| trace_dump_call_time(call_end_time - call_start_time); |
| trace_dump_indent(1); |
| trace_dump_tag_end("call"); |
| trace_dump_newline(); |
| fflush(stream); |
| } |
| void trace_dump_call_begin(const char *klass, const char *method) |
| { |
| pipe_mutex_lock(call_mutex); |
| trace_dump_call_begin_locked(klass, method); |
| } |
| void trace_dump_call_end(void) |
| { |
| trace_dump_call_end_locked(); |
| pipe_mutex_unlock(call_mutex); |
| } |
| void trace_dump_arg_begin(const char *name) |
| { |
| if (!dumping) |
| return; |
| trace_dump_indent(2); |
| trace_dump_tag_begin1("arg", "name", name); |
| } |
| void trace_dump_arg_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_tag_end("arg"); |
| trace_dump_newline(); |
| } |
| void trace_dump_ret_begin(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_indent(2); |
| trace_dump_tag_begin("ret"); |
| } |
| void trace_dump_ret_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_tag_end("ret"); |
| trace_dump_newline(); |
| } |
| void trace_dump_bool(int value) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<bool>%c</bool>", value ? '1' : '0'); |
| } |
| void trace_dump_int(long long int value) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<int>%lli</int>", value); |
| } |
| void trace_dump_uint(long long unsigned value) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<uint>%llu</uint>", value); |
| } |
| void trace_dump_float(double value) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<float>%g</float>", value); |
| } |
| void trace_dump_bytes(const void *data, |
| size_t size) |
| { |
| static const char hex_table[16] = "0123456789ABCDEF"; |
| const uint8_t *p = data; |
| size_t i; |
| if (!dumping) |
| return; |
| trace_dump_writes("<bytes>"); |
| for(i = 0; i < size; ++i) { |
| uint8_t byte = *p++; |
| char hex[2]; |
| hex[0] = hex_table[byte >> 4]; |
| hex[1] = hex_table[byte & 0xf]; |
| trace_dump_write(hex, 2); |
| } |
| trace_dump_writes("</bytes>"); |
| } |
| void trace_dump_box_bytes(const void *data, |
| struct pipe_resource *resource, |
| const struct pipe_box *box, |
| unsigned stride, |
| unsigned slice_stride) |
| { |
| size_t size; |
| /* |
| * Only dump buffer transfers to avoid huge files. |
| * TODO: Make this run-time configurable |
| */ |
| if (resource->target != PIPE_BUFFER) { |
| size = 0; |
| } else { |
| enum pipe_format format = resource->format; |
| if (slice_stride) |
| size = box->depth * slice_stride; |
| else if (stride) |
| size = util_format_get_nblocksy(format, box->height) * stride; |
| else { |
| size = util_format_get_nblocksx(format, box->width) * util_format_get_blocksize(format); |
| } |
| } |
| trace_dump_bytes(data, size); |
| } |
| void trace_dump_string(const char *str) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("<string>"); |
| trace_dump_escape(str); |
| trace_dump_writes("</string>"); |
| } |
| void trace_dump_enum(const char *value) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("<enum>"); |
| trace_dump_escape(value); |
| trace_dump_writes("</enum>"); |
| } |
| void trace_dump_array_begin(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("<array>"); |
| } |
| void trace_dump_array_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("</array>"); |
| } |
| void trace_dump_elem_begin(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("<elem>"); |
| } |
| void trace_dump_elem_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("</elem>"); |
| } |
| void trace_dump_struct_begin(const char *name) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<struct name='%s'>", name); |
| } |
| void trace_dump_struct_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("</struct>"); |
| } |
| void trace_dump_member_begin(const char *name) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writef("<member name='%s'>", name); |
| } |
| void trace_dump_member_end(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("</member>"); |
| } |
| void trace_dump_null(void) |
| { |
| if (!dumping) |
| return; |
| trace_dump_writes("<null/>"); |
| } |
| void trace_dump_ptr(const void *value) |
| { |
| if (!dumping) |
| return; |
| if(value) |
| trace_dump_writef("<ptr>0x%08lx</ptr>", (unsigned long)(uintptr_t)value); |
| else |
| trace_dump_null(); |
| } |
| void trace_dump_resource_ptr(struct pipe_resource *_resource) |
| { |
| if (!dumping) |
| return; |
| if (_resource) { |
| struct trace_resource *tr_resource = trace_resource(_resource); |
| trace_dump_ptr(tr_resource->resource); |
| } else { |
| trace_dump_null(); |
| } |
| } |
| void trace_dump_surface_ptr(struct pipe_surface *_surface) |
| { |
| if (!dumping) |
| return; |
| if (_surface) { |
| struct trace_surface *tr_surf = trace_surface(_surface); |
| trace_dump_ptr(tr_surf->surface); |
| } else { |
| trace_dump_null(); |
| } |
| } |
| void trace_dump_transfer_ptr(struct pipe_transfer *_transfer) |
| { |
| if (!dumping) |
| return; |
| if (_transfer) { |
| struct trace_transfer *tr_tran = trace_transfer(_transfer); |
| trace_dump_ptr(tr_tran->transfer); |
| } else { |
| trace_dump_null(); |
| } |
| } |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_dump.h |
|---|
| 0,0 → 1,191 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| /** |
| * @file |
| * Trace data dumping primitives. |
| */ |
| #ifndef TR_DUMP_H |
| #define TR_DUMP_H |
| #include "pipe/p_compiler.h" |
| #include "pipe/p_format.h" |
| struct pipe_resource; |
| struct pipe_surface; |
| struct pipe_transfer; |
| struct pipe_box; |
| /* |
| * Low level dumping controls. |
| * |
| * Opening the trace file and checking if that is opened. |
| */ |
| boolean trace_dump_trace_begin(void); |
| boolean trace_dump_trace_enabled(void); |
| void trace_dump_trace_flush(void); |
| /* |
| * Lock and unlock the call mutex. |
| * |
| * It used by the none locked version of dumping control |
| * and begin/end call dump functions. |
| * |
| * Begin takes the lock while end unlocks it. Use the _locked |
| * version to avoid locking/unlocking it. |
| */ |
| void trace_dump_call_lock(void); |
| void trace_dump_call_unlock(void); |
| /* |
| * High level dumping control. |
| */ |
| void trace_dumping_start_locked(void); |
| void trace_dumping_stop_locked(void); |
| boolean trace_dumping_enabled_locked(void); |
| void trace_dumping_start(void); |
| void trace_dumping_stop(void); |
| boolean trace_dumping_enabled(void); |
| void trace_dump_call_begin_locked(const char *klass, const char *method); |
| void trace_dump_call_end_locked(void); |
| void trace_dump_call_begin(const char *klass, const char *method); |
| void trace_dump_call_end(void); |
| void trace_dump_arg_begin(const char *name); |
| void trace_dump_arg_end(void); |
| void trace_dump_ret_begin(void); |
| void trace_dump_ret_end(void); |
| void trace_dump_bool(int value); |
| void trace_dump_int(long long int value); |
| void trace_dump_uint(long long unsigned value); |
| void trace_dump_float(double value); |
| void trace_dump_bytes(const void *data, size_t size); |
| void trace_dump_box_bytes(const void *data, |
| struct pipe_resource *resource, |
| const struct pipe_box *box, |
| unsigned stride, |
| unsigned slice_stride); |
| void trace_dump_string(const char *str); |
| void trace_dump_enum(const char *value); |
| void trace_dump_array_begin(void); |
| void trace_dump_array_end(void); |
| void trace_dump_elem_begin(void); |
| void trace_dump_elem_end(void); |
| void trace_dump_struct_begin(const char *name); |
| void trace_dump_struct_end(void); |
| void trace_dump_member_begin(const char *name); |
| void trace_dump_member_end(void); |
| void trace_dump_null(void); |
| void trace_dump_ptr(const void *value); |
| /* will turn a wrapped object into the real one and dump ptr */ |
| void trace_dump_resource_ptr(struct pipe_resource *_texture); |
| void trace_dump_surface_ptr(struct pipe_surface *_surface); |
| void trace_dump_transfer_ptr(struct pipe_transfer *_transfer); |
| /* |
| * Code saving macros. |
| */ |
| #define trace_dump_arg(_type, _arg) \ |
| do { \ |
| trace_dump_arg_begin(#_arg); \ |
| trace_dump_##_type(_arg); \ |
| trace_dump_arg_end(); \ |
| } while(0) |
| #define trace_dump_arg_struct(_type, _arg) \ |
| do { \ |
| trace_dump_arg_begin(#_arg); \ |
| trace_dump_##_type(&_arg); \ |
| trace_dump_arg_end(); \ |
| } while(0) |
| #define trace_dump_ret(_type, _arg) \ |
| do { \ |
| trace_dump_ret_begin(); \ |
| trace_dump_##_type(_arg); \ |
| trace_dump_ret_end(); \ |
| } while(0) |
| #define trace_dump_array(_type, _obj, _size) \ |
| do { \ |
| if (_obj) { \ |
| size_t idx; \ |
| trace_dump_array_begin(); \ |
| for(idx = 0; idx < (_size); ++idx) { \ |
| trace_dump_elem_begin(); \ |
| trace_dump_##_type((_obj)[idx]); \ |
| trace_dump_elem_end(); \ |
| } \ |
| trace_dump_array_end(); \ |
| } else { \ |
| trace_dump_null(); \ |
| } \ |
| } while(0) |
| #define trace_dump_struct_array(_type, _obj, _size) \ |
| do { \ |
| if (_obj) { \ |
| size_t idx; \ |
| trace_dump_array_begin(); \ |
| for(idx = 0; idx < (_size); ++idx) { \ |
| trace_dump_elem_begin(); \ |
| trace_dump_##_type(&(_obj)[idx]); \ |
| trace_dump_elem_end(); \ |
| } \ |
| trace_dump_array_end(); \ |
| } else { \ |
| trace_dump_null(); \ |
| } \ |
| } while(0) |
| #define trace_dump_member(_type, _obj, _member) \ |
| do { \ |
| trace_dump_member_begin(#_member); \ |
| trace_dump_##_type((_obj)->_member); \ |
| trace_dump_member_end(); \ |
| } while(0) |
| #define trace_dump_arg_array(_type, _arg, _size) \ |
| do { \ |
| trace_dump_arg_begin(#_arg); \ |
| trace_dump_array(_type, _arg, _size); \ |
| trace_dump_arg_end(); \ |
| } while(0) |
| #define trace_dump_member_array(_type, _obj, _member) \ |
| do { \ |
| trace_dump_member_begin(#_member); \ |
| trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ |
| trace_dump_member_end(); \ |
| } while(0) |
| #endif /* TR_DUMP_H */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_dump_state.c |
|---|
| 0,0 → 1,771 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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_compiler.h" |
| #include "util/u_memory.h" |
| #include "util/u_format.h" |
| #include "tgsi/tgsi_dump.h" |
| #include "tr_dump.h" |
| #include "tr_dump_state.h" |
| void trace_dump_format(enum pipe_format format) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| trace_dump_enum(util_format_name(format) ); |
| } |
| void trace_dump_resource_template(const struct pipe_resource *templat) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!templat) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_resource"); |
| trace_dump_member(int, templat, target); |
| trace_dump_member(format, templat, format); |
| trace_dump_member_begin("width"); |
| trace_dump_uint(templat->width0); |
| trace_dump_member_end(); |
| trace_dump_member_begin("height"); |
| trace_dump_uint(templat->height0); |
| trace_dump_member_end(); |
| trace_dump_member_begin("depth"); |
| trace_dump_uint(templat->depth0); |
| trace_dump_member_end(); |
| trace_dump_member_begin("array_size"); |
| trace_dump_uint(templat->array_size); |
| trace_dump_member_end(); |
| trace_dump_member(uint, templat, last_level); |
| trace_dump_member(uint, templat, nr_samples); |
| trace_dump_member(uint, templat, usage); |
| trace_dump_member(uint, templat, bind); |
| trace_dump_member(uint, templat, flags); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_box(const struct pipe_box *box) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!box) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_box"); |
| trace_dump_member(int, box, x); |
| trace_dump_member(int, box, y); |
| trace_dump_member(int, box, z); |
| trace_dump_member(int, box, width); |
| trace_dump_member(int, box, height); |
| trace_dump_member(int, box, depth); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_rasterizer_state"); |
| trace_dump_member(bool, state, flatshade); |
| trace_dump_member(bool, state, light_twoside); |
| trace_dump_member(bool, state, clamp_vertex_color); |
| trace_dump_member(bool, state, clamp_fragment_color); |
| trace_dump_member(uint, state, front_ccw); |
| trace_dump_member(uint, state, cull_face); |
| trace_dump_member(uint, state, fill_front); |
| trace_dump_member(uint, state, fill_back); |
| trace_dump_member(bool, state, offset_point); |
| trace_dump_member(bool, state, offset_line); |
| trace_dump_member(bool, state, offset_tri); |
| trace_dump_member(bool, state, scissor); |
| trace_dump_member(bool, state, poly_smooth); |
| trace_dump_member(bool, state, poly_stipple_enable); |
| trace_dump_member(bool, state, point_smooth); |
| trace_dump_member(uint, state, sprite_coord_enable); |
| trace_dump_member(bool, state, sprite_coord_mode); |
| trace_dump_member(bool, state, point_quad_rasterization); |
| trace_dump_member(bool, state, point_size_per_vertex); |
| trace_dump_member(bool, state, multisample); |
| trace_dump_member(bool, state, line_smooth); |
| trace_dump_member(bool, state, line_stipple_enable); |
| trace_dump_member(uint, state, line_stipple_factor); |
| trace_dump_member(uint, state, line_stipple_pattern); |
| trace_dump_member(bool, state, line_last_pixel); |
| trace_dump_member(bool, state, flatshade_first); |
| trace_dump_member(bool, state, half_pixel_center); |
| trace_dump_member(bool, state, bottom_edge_rule); |
| trace_dump_member(bool, state, rasterizer_discard); |
| trace_dump_member(bool, state, depth_clip); |
| trace_dump_member(bool, state, clip_halfz); |
| trace_dump_member(uint, state, clip_plane_enable); |
| trace_dump_member(float, state, line_width); |
| trace_dump_member(float, state, point_size); |
| trace_dump_member(float, state, offset_units); |
| trace_dump_member(float, state, offset_scale); |
| trace_dump_member(float, state, offset_clamp); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_poly_stipple(const struct pipe_poly_stipple *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_poly_stipple"); |
| trace_dump_member_begin("stipple"); |
| trace_dump_array(uint, |
| state->stipple, |
| Elements(state->stipple)); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_viewport_state(const struct pipe_viewport_state *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_viewport_state"); |
| trace_dump_member_array(float, state, scale); |
| trace_dump_member_array(float, state, translate); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_scissor_state(const struct pipe_scissor_state *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_scissor_state"); |
| trace_dump_member(uint, state, minx); |
| trace_dump_member(uint, state, miny); |
| trace_dump_member(uint, state, maxx); |
| trace_dump_member(uint, state, maxy); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_clip_state(const struct pipe_clip_state *state) |
| { |
| unsigned i; |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_clip_state"); |
| trace_dump_member_begin("ucp"); |
| trace_dump_array_begin(); |
| for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) { |
| trace_dump_elem_begin(); |
| trace_dump_array(float, state->ucp[i], 4); |
| trace_dump_elem_end(); |
| } |
| trace_dump_array_end(); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_shader_state(const struct pipe_shader_state *state) |
| { |
| static char str[8192]; |
| unsigned i; |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| tgsi_dump_str(state->tokens, 0, str, sizeof(str)); |
| trace_dump_struct_begin("pipe_shader_state"); |
| trace_dump_member_begin("tokens"); |
| trace_dump_string(str); |
| trace_dump_member_end(); |
| trace_dump_member_begin("stream_output"); |
| trace_dump_struct_begin("pipe_stream_output_info"); |
| trace_dump_member(uint, &state->stream_output, num_outputs); |
| trace_dump_member_array(uint, &state->stream_output, stride); |
| trace_dump_member_begin("output"); |
| trace_dump_array_begin(); |
| for(i = 0; i < state->stream_output.num_outputs; ++i) { |
| trace_dump_elem_begin(); |
| trace_dump_struct_begin(""); /* anonymous */ |
| trace_dump_member(uint, &state->stream_output.output[i], register_index); |
| trace_dump_member(uint, &state->stream_output.output[i], start_component); |
| trace_dump_member(uint, &state->stream_output.output[i], num_components); |
| trace_dump_member(uint, &state->stream_output.output[i], output_buffer); |
| trace_dump_member(uint, &state->stream_output.output[i], dst_offset); |
| trace_dump_struct_end(); |
| trace_dump_elem_end(); |
| } |
| trace_dump_array_end(); |
| trace_dump_member_end(); // output |
| trace_dump_struct_end(); |
| trace_dump_member_end(); // stream_output |
| trace_dump_struct_end(); |
| } |
| void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state) |
| { |
| unsigned i; |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_depth_stencil_alpha_state"); |
| trace_dump_member_begin("depth"); |
| trace_dump_struct_begin("pipe_depth_state"); |
| trace_dump_member(bool, &state->depth, enabled); |
| trace_dump_member(bool, &state->depth, writemask); |
| trace_dump_member(uint, &state->depth, func); |
| trace_dump_struct_end(); |
| trace_dump_member_end(); |
| trace_dump_member_begin("stencil"); |
| trace_dump_array_begin(); |
| for(i = 0; i < Elements(state->stencil); ++i) { |
| trace_dump_elem_begin(); |
| trace_dump_struct_begin("pipe_stencil_state"); |
| trace_dump_member(bool, &state->stencil[i], enabled); |
| trace_dump_member(uint, &state->stencil[i], func); |
| trace_dump_member(uint, &state->stencil[i], fail_op); |
| trace_dump_member(uint, &state->stencil[i], zpass_op); |
| trace_dump_member(uint, &state->stencil[i], zfail_op); |
| trace_dump_member(uint, &state->stencil[i], valuemask); |
| trace_dump_member(uint, &state->stencil[i], writemask); |
| trace_dump_struct_end(); |
| trace_dump_elem_end(); |
| } |
| trace_dump_array_end(); |
| trace_dump_member_end(); |
| trace_dump_member_begin("alpha"); |
| trace_dump_struct_begin("pipe_alpha_state"); |
| trace_dump_member(bool, &state->alpha, enabled); |
| trace_dump_member(uint, &state->alpha, func); |
| trace_dump_member(float, &state->alpha, ref_value); |
| trace_dump_struct_end(); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| } |
| static void trace_dump_rt_blend_state(const struct pipe_rt_blend_state *state) |
| { |
| trace_dump_struct_begin("pipe_rt_blend_state"); |
| trace_dump_member(uint, state, blend_enable); |
| trace_dump_member(uint, state, rgb_func); |
| trace_dump_member(uint, state, rgb_src_factor); |
| trace_dump_member(uint, state, rgb_dst_factor); |
| trace_dump_member(uint, state, alpha_func); |
| trace_dump_member(uint, state, alpha_src_factor); |
| trace_dump_member(uint, state, alpha_dst_factor); |
| trace_dump_member(uint, state, colormask); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_blend_state(const struct pipe_blend_state *state) |
| { |
| unsigned valid_entries = 1; |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_blend_state"); |
| trace_dump_member(bool, state, dither); |
| trace_dump_member(bool, state, logicop_enable); |
| trace_dump_member(uint, state, logicop_func); |
| trace_dump_member(bool, state, independent_blend_enable); |
| trace_dump_member_begin("rt"); |
| if (state->independent_blend_enable) |
| valid_entries = PIPE_MAX_COLOR_BUFS; |
| trace_dump_struct_array(rt_blend_state, state->rt, valid_entries); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_blend_color(const struct pipe_blend_color *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_blend_color"); |
| trace_dump_member_array(float, state, color); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_stencil_ref(const struct pipe_stencil_ref *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_stencil_ref"); |
| trace_dump_member_array(uint, state, ref_value); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| trace_dump_struct_begin("pipe_framebuffer_state"); |
| trace_dump_member(uint, state, width); |
| trace_dump_member(uint, state, height); |
| trace_dump_member(uint, state, nr_cbufs); |
| trace_dump_member_array(ptr, state, cbufs); |
| trace_dump_member(ptr, state, zsbuf); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_sampler_state(const struct pipe_sampler_state *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_sampler_state"); |
| trace_dump_member(uint, state, wrap_s); |
| trace_dump_member(uint, state, wrap_t); |
| trace_dump_member(uint, state, wrap_r); |
| trace_dump_member(uint, state, min_img_filter); |
| trace_dump_member(uint, state, min_mip_filter); |
| trace_dump_member(uint, state, mag_img_filter); |
| trace_dump_member(uint, state, compare_mode); |
| trace_dump_member(uint, state, compare_func); |
| trace_dump_member(bool, state, normalized_coords); |
| trace_dump_member(uint, state, max_anisotropy); |
| trace_dump_member(float, state, lod_bias); |
| trace_dump_member(float, state, min_lod); |
| trace_dump_member(float, state, max_lod); |
| trace_dump_member_array(float, state, border_color.f); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_sampler_view_template(const struct pipe_sampler_view *state, |
| enum pipe_texture_target target) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_sampler_view"); |
| trace_dump_member(format, state, format); |
| trace_dump_member_begin("u"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| if (target == PIPE_BUFFER) { |
| trace_dump_member_begin("buf"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| trace_dump_member(uint, &state->u.buf, first_element); |
| trace_dump_member(uint, &state->u.buf, last_element); |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* buf */ |
| } else { |
| trace_dump_member_begin("tex"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| trace_dump_member(uint, &state->u.tex, first_layer); |
| trace_dump_member(uint, &state->u.tex, last_layer); |
| trace_dump_member(uint, &state->u.tex, first_level); |
| trace_dump_member(uint, &state->u.tex, last_level); |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* tex */ |
| } |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* u */ |
| trace_dump_member(uint, state, swizzle_r); |
| trace_dump_member(uint, state, swizzle_g); |
| trace_dump_member(uint, state, swizzle_b); |
| trace_dump_member(uint, state, swizzle_a); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_surface_template(const struct pipe_surface *state, |
| enum pipe_texture_target target) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_surface"); |
| trace_dump_member(format, state, format); |
| trace_dump_member(uint, state, width); |
| trace_dump_member(uint, state, height); |
| trace_dump_member_begin("u"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| if (target == PIPE_BUFFER) { |
| trace_dump_member_begin("buf"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| trace_dump_member(uint, &state->u.buf, first_element); |
| trace_dump_member(uint, &state->u.buf, last_element); |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* buf */ |
| } else { |
| trace_dump_member_begin("tex"); |
| trace_dump_struct_begin(""); /* anonymous */ |
| trace_dump_member(uint, &state->u.tex, level); |
| trace_dump_member(uint, &state->u.tex, first_layer); |
| trace_dump_member(uint, &state->u.tex, last_layer); |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* tex */ |
| } |
| trace_dump_struct_end(); /* anonymous */ |
| trace_dump_member_end(); /* u */ |
| trace_dump_struct_end(); |
| } |
| void trace_dump_transfer(const struct pipe_transfer *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_transfer"); |
| trace_dump_member(uint, state, box.x); |
| trace_dump_member(uint, state, box.y); |
| trace_dump_member(uint, state, box.z); |
| trace_dump_member(uint, state, box.width); |
| trace_dump_member(uint, state, box.height); |
| trace_dump_member(uint, state, box.depth); |
| trace_dump_member(uint, state, stride); |
| trace_dump_member(uint, state, layer_stride); |
| trace_dump_member(uint, state, usage); |
| trace_dump_member(ptr, state, resource); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_vertex_buffer"); |
| trace_dump_member(uint, state, stride); |
| trace_dump_member(uint, state, buffer_offset); |
| trace_dump_member(resource_ptr, state, buffer); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_index_buffer(const struct pipe_index_buffer *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_index_buffer"); |
| trace_dump_member(uint, state, index_size); |
| trace_dump_member(uint, state, offset); |
| trace_dump_member(resource_ptr, state, buffer); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_vertex_element(const struct pipe_vertex_element *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_vertex_element"); |
| trace_dump_member(uint, state, src_offset); |
| trace_dump_member(uint, state, vertex_buffer_index); |
| trace_dump_member(format, state, src_format); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_constant_buffer(const struct pipe_constant_buffer *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_constant_buffer"); |
| trace_dump_member(ptr, state, buffer); |
| trace_dump_member(uint, state, buffer_offset); |
| trace_dump_member(uint, state, buffer_size); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_draw_info(const struct pipe_draw_info *state) |
| { |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if(!state) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_draw_info"); |
| trace_dump_member(bool, state, indexed); |
| trace_dump_member(uint, state, mode); |
| trace_dump_member(uint, state, start); |
| trace_dump_member(uint, state, count); |
| trace_dump_member(uint, state, start_instance); |
| trace_dump_member(uint, state, instance_count); |
| trace_dump_member(int, state, index_bias); |
| trace_dump_member(uint, state, min_index); |
| trace_dump_member(uint, state, max_index); |
| trace_dump_member(bool, state, primitive_restart); |
| trace_dump_member(uint, state, restart_index); |
| trace_dump_member(ptr, state, count_from_stream_output); |
| trace_dump_struct_end(); |
| } |
| void trace_dump_blit_info(const struct pipe_blit_info *info) |
| { |
| char mask[7]; |
| if (!trace_dumping_enabled_locked()) |
| return; |
| if (!info) { |
| trace_dump_null(); |
| return; |
| } |
| trace_dump_struct_begin("pipe_blit_info"); |
| trace_dump_member_begin("dst"); |
| trace_dump_struct_begin("dst"); |
| trace_dump_member(resource_ptr, &info->dst, resource); |
| trace_dump_member(uint, &info->dst, level); |
| trace_dump_member(format, &info->dst, format); |
| trace_dump_member_begin("box"); |
| trace_dump_box(&info->dst.box); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| trace_dump_member_end(); |
| trace_dump_member_begin("src"); |
| trace_dump_struct_begin("src"); |
| trace_dump_member(resource_ptr, &info->src, resource); |
| trace_dump_member(uint, &info->src, level); |
| trace_dump_member(format, &info->src, format); |
| trace_dump_member_begin("box"); |
| trace_dump_box(&info->src.box); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| trace_dump_member_end(); |
| mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-'; |
| mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-'; |
| mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-'; |
| mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-'; |
| mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-'; |
| mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-'; |
| mask[6] = 0; |
| trace_dump_member_begin("mask"); |
| trace_dump_string(mask); |
| trace_dump_member_end(); |
| trace_dump_member(uint, info, filter); |
| trace_dump_member(bool, info, scissor_enable); |
| trace_dump_member_begin("scissor"); |
| trace_dump_scissor_state(&info->scissor); |
| trace_dump_member_end(); |
| trace_dump_struct_end(); |
| } |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_dump_state.h |
|---|
| 0,0 → 1,89 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| #ifndef TR_DUMP_STATE_H_ |
| #define TR_DUMP_STATE_H_ |
| #include "pipe/p_format.h" |
| #include "pipe/p_state.h" |
| #include "pipe/p_shader_tokens.h" |
| void trace_dump_format(enum pipe_format format); |
| void trace_dump_resource_template(const struct pipe_resource *templat); |
| void trace_dump_box(const struct pipe_box *box); |
| void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state); |
| void trace_dump_poly_stipple(const struct pipe_poly_stipple *state); |
| void trace_dump_viewport_state(const struct pipe_viewport_state *state); |
| void trace_dump_scissor_state(const struct pipe_scissor_state *state); |
| void trace_dump_clip_state(const struct pipe_clip_state *state); |
| void trace_dump_token(const struct tgsi_token *token); |
| void trace_dump_shader_state(const struct pipe_shader_state *state); |
| void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state); |
| void trace_dump_blend_state(const struct pipe_blend_state *state); |
| void trace_dump_blend_color(const struct pipe_blend_color *state); |
| void trace_dump_stencil_ref(const struct pipe_stencil_ref *state); |
| void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state); |
| void trace_dump_sampler_state(const struct pipe_sampler_state *state); |
| void trace_dump_sampler_view_template(const struct pipe_sampler_view *view, |
| enum pipe_texture_target target); |
| void trace_dump_surface_template(const struct pipe_surface *state, |
| enum pipe_texture_target target); |
| void trace_dump_transfer(const struct pipe_transfer *state); |
| void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state); |
| void trace_dump_index_buffer(const struct pipe_index_buffer *state); |
| void trace_dump_vertex_element(const struct pipe_vertex_element *state); |
| void trace_dump_constant_buffer(const struct pipe_constant_buffer *state); |
| void trace_dump_draw_info(const struct pipe_draw_info *state); |
| void trace_dump_blit_info(const struct pipe_blit_info *); |
| #endif /* TR_STATE_H */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_public.h |
|---|
| 0,0 → 1,48 |
| /************************************************************************** |
| * |
| * Copyright 2010 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 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 |
| * THE COPYRIGHT HOLDERS, AUTHORS 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. |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| **************************************************************************/ |
| #ifndef TR_PUBLIC_H |
| #define TR_PUBLIC_H |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| struct pipe_screen; |
| struct pipe_context; |
| struct pipe_screen * |
| trace_screen_create(struct pipe_screen *screen); |
| boolean |
| trace_enabled(void); |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* TR_PUBLIC_H */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_screen.c |
|---|
| 0,0 → 1,510 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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 "util/u_format.h" |
| #include "util/u_memory.h" |
| #include "util/u_simple_list.h" |
| #include "tr_dump.h" |
| #include "tr_dump_state.h" |
| #include "tr_texture.h" |
| #include "tr_context.h" |
| #include "tr_screen.h" |
| #include "tr_public.h" |
| #include "pipe/p_format.h" |
| static boolean trace = FALSE; |
| static const char * |
| trace_screen_get_name(struct pipe_screen *_screen) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| const char *result; |
| trace_dump_call_begin("pipe_screen", "get_name"); |
| trace_dump_arg(ptr, screen); |
| result = screen->get_name(screen); |
| trace_dump_ret(string, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static const char * |
| trace_screen_get_vendor(struct pipe_screen *_screen) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| const char *result; |
| trace_dump_call_begin("pipe_screen", "get_vendor"); |
| trace_dump_arg(ptr, screen); |
| result = screen->get_vendor(screen); |
| trace_dump_ret(string, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static int |
| trace_screen_get_param(struct pipe_screen *_screen, |
| enum pipe_cap param) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| int result; |
| trace_dump_call_begin("pipe_screen", "get_param"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(int, param); |
| result = screen->get_param(screen, param); |
| trace_dump_ret(int, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static int |
| trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader, |
| enum pipe_shader_cap param) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| int result; |
| trace_dump_call_begin("pipe_screen", "get_shader_param"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(uint, shader); |
| trace_dump_arg(int, param); |
| result = screen->get_shader_param(screen, shader, param); |
| trace_dump_ret(int, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static float |
| trace_screen_get_paramf(struct pipe_screen *_screen, |
| enum pipe_capf param) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| float result; |
| trace_dump_call_begin("pipe_screen", "get_paramf"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(int, param); |
| result = screen->get_paramf(screen, param); |
| trace_dump_ret(float, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static boolean |
| trace_screen_is_format_supported(struct pipe_screen *_screen, |
| enum pipe_format format, |
| enum pipe_texture_target target, |
| unsigned sample_count, |
| unsigned tex_usage) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| boolean result; |
| trace_dump_call_begin("pipe_screen", "is_format_supported"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(format, format); |
| trace_dump_arg(int, target); |
| trace_dump_arg(uint, sample_count); |
| trace_dump_arg(uint, tex_usage); |
| result = screen->is_format_supported(screen, format, target, sample_count, |
| tex_usage); |
| trace_dump_ret(bool, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static struct pipe_context * |
| trace_screen_context_create(struct pipe_screen *_screen, void *priv) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| struct pipe_context *result; |
| trace_dump_call_begin("pipe_screen", "context_create"); |
| trace_dump_arg(ptr, screen); |
| result = screen->context_create(screen, priv); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| result = trace_context_create(tr_scr, result); |
| return result; |
| } |
| static void |
| trace_screen_flush_frontbuffer(struct pipe_screen *_screen, |
| struct pipe_resource *_resource, |
| unsigned level, unsigned layer, |
| void *context_private) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_screen *screen = tr_scr->screen; |
| struct pipe_resource *resource = tr_res->resource; |
| trace_dump_call_begin("pipe_screen", "flush_frontbuffer"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(ptr, resource); |
| trace_dump_arg(uint, level); |
| trace_dump_arg(uint, layer); |
| /* XXX: hide, as there is nothing we can do with this |
| trace_dump_arg(ptr, context_private); |
| */ |
| screen->flush_frontbuffer(screen, resource, level, layer, context_private); |
| trace_dump_call_end(); |
| } |
| /******************************************************************** |
| * texture |
| */ |
| static struct pipe_resource * |
| trace_screen_resource_create(struct pipe_screen *_screen, |
| const struct pipe_resource *templat) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| struct pipe_resource *result; |
| trace_dump_call_begin("pipe_screen", "resource_create"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(resource_template, templat); |
| result = screen->resource_create(screen, templat); |
| trace_dump_ret(ptr, result); |
| trace_dump_call_end(); |
| result = trace_resource_create(tr_scr, result); |
| return result; |
| } |
| static struct pipe_resource * |
| trace_screen_resource_from_handle(struct pipe_screen *_screen, |
| const struct pipe_resource *templ, |
| struct winsys_handle *handle) |
| { |
| struct trace_screen *tr_screen = trace_screen(_screen); |
| struct pipe_screen *screen = tr_screen->screen; |
| struct pipe_resource *result; |
| /* TODO trace call */ |
| result = screen->resource_from_handle(screen, templ, handle); |
| result = trace_resource_create(trace_screen(_screen), result); |
| return result; |
| } |
| static boolean |
| trace_screen_resource_get_handle(struct pipe_screen *_screen, |
| struct pipe_resource *_resource, |
| struct winsys_handle *handle) |
| { |
| struct trace_screen *tr_screen = trace_screen(_screen); |
| struct trace_resource *tr_resource = trace_resource(_resource); |
| struct pipe_screen *screen = tr_screen->screen; |
| struct pipe_resource *resource = tr_resource->resource; |
| /* TODO trace call */ |
| return screen->resource_get_handle(screen, resource, handle); |
| } |
| static void |
| trace_screen_resource_destroy(struct pipe_screen *_screen, |
| struct pipe_resource *_resource) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct trace_resource *tr_res = trace_resource(_resource); |
| struct pipe_screen *screen = tr_scr->screen; |
| struct pipe_resource *resource = tr_res->resource; |
| assert(resource->screen == screen); |
| trace_dump_call_begin("pipe_screen", "resource_destroy"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(ptr, resource); |
| trace_dump_call_end(); |
| trace_resource_destroy(tr_scr, tr_res); |
| } |
| /******************************************************************** |
| * fence |
| */ |
| static void |
| trace_screen_fence_reference(struct pipe_screen *_screen, |
| struct pipe_fence_handle **pdst, |
| struct pipe_fence_handle *src) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| struct pipe_fence_handle *dst; |
| assert(pdst); |
| dst = *pdst; |
| trace_dump_call_begin("pipe_screen", "fence_reference"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(ptr, dst); |
| trace_dump_arg(ptr, src); |
| screen->fence_reference(screen, pdst, src); |
| trace_dump_call_end(); |
| } |
| static boolean |
| trace_screen_fence_signalled(struct pipe_screen *_screen, |
| struct pipe_fence_handle *fence) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| int result; |
| trace_dump_call_begin("pipe_screen", "fence_signalled"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(ptr, fence); |
| result = screen->fence_signalled(screen, fence); |
| trace_dump_ret(bool, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static boolean |
| trace_screen_fence_finish(struct pipe_screen *_screen, |
| struct pipe_fence_handle *fence, |
| uint64_t timeout) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| int result; |
| trace_dump_call_begin("pipe_screen", "fence_finish"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_arg(ptr, fence); |
| trace_dump_arg(uint, timeout); |
| result = screen->fence_finish(screen, fence, timeout); |
| trace_dump_ret(bool, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| /******************************************************************** |
| * screen |
| */ |
| static uint64_t |
| trace_screen_get_timestamp(struct pipe_screen *_screen) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| uint64_t result; |
| trace_dump_call_begin("pipe_screen", "get_timestamp"); |
| trace_dump_arg(ptr, screen); |
| result = screen->get_timestamp(screen); |
| trace_dump_ret(uint, result); |
| trace_dump_call_end(); |
| return result; |
| } |
| static void |
| trace_screen_destroy(struct pipe_screen *_screen) |
| { |
| struct trace_screen *tr_scr = trace_screen(_screen); |
| struct pipe_screen *screen = tr_scr->screen; |
| trace_dump_call_begin("pipe_screen", "destroy"); |
| trace_dump_arg(ptr, screen); |
| trace_dump_call_end(); |
| screen->destroy(screen); |
| FREE(tr_scr); |
| } |
| boolean |
| trace_enabled(void) |
| { |
| static boolean firstrun = TRUE; |
| if (!firstrun) |
| return trace; |
| firstrun = FALSE; |
| if(trace_dump_trace_begin()) { |
| trace_dumping_start(); |
| trace = TRUE; |
| } |
| return trace; |
| } |
| struct pipe_screen * |
| trace_screen_create(struct pipe_screen *screen) |
| { |
| struct trace_screen *tr_scr; |
| if(!screen) |
| goto error1; |
| if (!trace_enabled()) |
| goto error1; |
| trace_dump_call_begin("", "pipe_screen_create"); |
| tr_scr = CALLOC_STRUCT(trace_screen); |
| if(!tr_scr) |
| goto error2; |
| tr_scr->base.destroy = trace_screen_destroy; |
| tr_scr->base.get_name = trace_screen_get_name; |
| tr_scr->base.get_vendor = trace_screen_get_vendor; |
| tr_scr->base.get_param = trace_screen_get_param; |
| tr_scr->base.get_shader_param = trace_screen_get_shader_param; |
| tr_scr->base.get_paramf = trace_screen_get_paramf; |
| tr_scr->base.is_format_supported = trace_screen_is_format_supported; |
| assert(screen->context_create); |
| tr_scr->base.context_create = trace_screen_context_create; |
| tr_scr->base.resource_create = trace_screen_resource_create; |
| tr_scr->base.resource_from_handle = trace_screen_resource_from_handle; |
| tr_scr->base.resource_get_handle = trace_screen_resource_get_handle; |
| tr_scr->base.resource_destroy = trace_screen_resource_destroy; |
| tr_scr->base.fence_reference = trace_screen_fence_reference; |
| tr_scr->base.fence_signalled = trace_screen_fence_signalled; |
| tr_scr->base.fence_finish = trace_screen_fence_finish; |
| tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer; |
| tr_scr->base.get_timestamp = trace_screen_get_timestamp; |
| tr_scr->screen = screen; |
| trace_dump_ret(ptr, screen); |
| trace_dump_call_end(); |
| return &tr_scr->base; |
| error2: |
| trace_dump_ret(ptr, screen); |
| trace_dump_call_end(); |
| error1: |
| return screen; |
| } |
| struct trace_screen * |
| trace_screen(struct pipe_screen *screen) |
| { |
| assert(screen); |
| assert(screen->destroy == trace_screen_destroy); |
| return (struct trace_screen *)screen; |
| } |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_screen.h |
|---|
| 0,0 → 1,65 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| #ifndef TR_SCREEN_H_ |
| #define TR_SCREEN_H_ |
| #include "pipe/p_screen.h" |
| #include "os/os_thread.h" |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| /** |
| * It often happens that new data is written directly to the user buffers |
| * without mapping/unmapping. This flag marks user buffers, so that their |
| * contents can be dumped before being used by the pipe context. |
| */ |
| #define TRACE_FLAG_USER_BUFFER (1 << 31) |
| struct trace_screen |
| { |
| struct pipe_screen base; |
| struct pipe_screen *screen; |
| }; |
| struct trace_screen * |
| trace_screen(struct pipe_screen *screen); |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* TR_SCREEN_H_ */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_texture.c |
|---|
| 0,0 → 1,157 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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 "util/u_inlines.h" |
| #include "util/u_hash_table.h" |
| #include "util/u_memory.h" |
| #include "util/u_simple_list.h" |
| #include "tr_screen.h" |
| #include "tr_context.h" |
| #include "tr_texture.h" |
| struct pipe_resource * |
| trace_resource_create(struct trace_screen *tr_scr, |
| struct pipe_resource *texture) |
| { |
| struct trace_resource *tr_res; |
| if(!texture) |
| goto error; |
| assert(texture->screen == tr_scr->screen); |
| tr_res = CALLOC_STRUCT(trace_resource); |
| if(!tr_res) |
| goto error; |
| memcpy(&tr_res->base, texture, sizeof(struct pipe_resource)); |
| pipe_reference_init(&tr_res->base.reference, 1); |
| tr_res->base.screen = &tr_scr->base; |
| tr_res->resource = texture; |
| return &tr_res->base; |
| error: |
| pipe_resource_reference(&texture, NULL); |
| return NULL; |
| } |
| void |
| trace_resource_destroy(struct trace_screen *tr_scr, |
| struct trace_resource *tr_res) |
| { |
| pipe_resource_reference(&tr_res->resource, NULL); |
| FREE(tr_res); |
| } |
| struct pipe_surface * |
| trace_surf_create(struct trace_context *tr_ctx, |
| struct trace_resource *tr_res, |
| struct pipe_surface *surface) |
| { |
| struct trace_surface *tr_surf; |
| if(!surface) |
| goto error; |
| assert(surface->texture == tr_res->resource); |
| tr_surf = CALLOC_STRUCT(trace_surface); |
| if(!tr_surf) |
| goto error; |
| memcpy(&tr_surf->base, surface, sizeof(struct pipe_surface)); |
| tr_surf->base.context = &tr_ctx->base; |
| pipe_reference_init(&tr_surf->base.reference, 1); |
| tr_surf->base.texture = NULL; |
| pipe_resource_reference(&tr_surf->base.texture, &tr_res->base); |
| tr_surf->surface = surface; |
| return &tr_surf->base; |
| error: |
| pipe_surface_reference(&surface, NULL); |
| return NULL; |
| } |
| void |
| trace_surf_destroy(struct trace_surface *tr_surf) |
| { |
| trace_context_check(tr_surf->base.context); |
| pipe_resource_reference(&tr_surf->base.texture, NULL); |
| pipe_surface_reference(&tr_surf->surface, NULL); |
| FREE(tr_surf); |
| } |
| struct pipe_transfer * |
| trace_transfer_create(struct trace_context *tr_ctx, |
| struct trace_resource *tr_res, |
| struct pipe_transfer *transfer) |
| { |
| struct trace_transfer *tr_trans; |
| if(!transfer) |
| goto error; |
| assert(transfer->resource == tr_res->resource); |
| tr_trans = CALLOC_STRUCT(trace_transfer); |
| if(!tr_trans) |
| goto error; |
| memcpy(&tr_trans->base, transfer, sizeof(struct pipe_transfer)); |
| tr_trans->base.resource = NULL; |
| tr_trans->transfer = transfer; |
| pipe_resource_reference(&tr_trans->base.resource, &tr_res->base); |
| assert(tr_trans->base.resource == &tr_res->base); |
| return &tr_trans->base; |
| error: |
| tr_ctx->pipe->transfer_unmap(tr_ctx->pipe, transfer); |
| return NULL; |
| } |
| void |
| trace_transfer_destroy(struct trace_context *tr_context, |
| struct trace_transfer *tr_trans) |
| { |
| pipe_resource_reference(&tr_trans->base.resource, NULL); |
| FREE(tr_trans); |
| } |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/tr_texture.h |
|---|
| 0,0 → 1,153 |
| /************************************************************************** |
| * |
| * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
| * 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. |
| * |
| **************************************************************************/ |
| #ifndef TR_TEXTURE_H_ |
| #define TR_TEXTURE_H_ |
| #include "pipe/p_compiler.h" |
| #include "pipe/p_state.h" |
| #include "tr_screen.h" |
| struct trace_context; |
| struct tr_list |
| { |
| struct tr_list *next; |
| struct tr_list *prev; |
| }; |
| struct trace_resource |
| { |
| struct pipe_resource base; |
| struct pipe_resource *resource; |
| struct tr_list list; |
| }; |
| struct trace_surface |
| { |
| struct pipe_surface base; |
| struct pipe_surface *surface; |
| struct tr_list list; |
| }; |
| struct trace_sampler_view |
| { |
| struct pipe_sampler_view base; |
| struct pipe_sampler_view *sampler_view; |
| }; |
| struct trace_transfer |
| { |
| struct pipe_transfer base; |
| struct pipe_transfer *transfer; |
| struct pipe_context *pipe; |
| struct tr_list list; |
| void *map; |
| }; |
| static INLINE struct trace_resource * |
| trace_resource(struct pipe_resource *texture) |
| { |
| if(!texture) |
| return NULL; |
| (void)trace_screen(texture->screen); |
| return (struct trace_resource *)texture; |
| } |
| static INLINE struct trace_surface * |
| trace_surface(struct pipe_surface *surface) |
| { |
| if(!surface) |
| return NULL; |
| (void)trace_resource(surface->texture); |
| return (struct trace_surface *)surface; |
| } |
| static INLINE struct trace_sampler_view * |
| trace_sampler_view(struct pipe_sampler_view *sampler_view) |
| { |
| if (!sampler_view) |
| return NULL; |
| return (struct trace_sampler_view *)sampler_view; |
| } |
| static INLINE struct trace_transfer * |
| trace_transfer(struct pipe_transfer *transfer) |
| { |
| if(!transfer) |
| return NULL; |
| (void)trace_resource(transfer->resource); |
| return (struct trace_transfer *)transfer; |
| } |
| struct pipe_resource * |
| trace_resource_create(struct trace_screen *tr_scr, |
| struct pipe_resource *texture); |
| void |
| trace_resource_destroy(struct trace_screen *tr_scr, |
| struct trace_resource *tr_res); |
| struct pipe_surface * |
| trace_surf_create(struct trace_context *tr_ctx, |
| struct trace_resource *tr_res, |
| struct pipe_surface *surface); |
| void |
| trace_surf_destroy(struct trace_surface *tr_surf); |
| struct pipe_transfer * |
| trace_transfer_create(struct trace_context *tr_ctx, |
| struct trace_resource *tr_res, |
| struct pipe_transfer *transfer); |
| void |
| trace_transfer_destroy(struct trace_context *tr_ctx, |
| struct trace_transfer *tr_trans); |
| #endif /* TR_TEXTURE_H_ */ |
| /contrib/sdk/sources/Mesa/src/gallium/drivers/trace/trace.xsl |
|---|
| 0,0 → 1,188 |
| <?xml version="1.0"?> |
| <!-- |
| Copyright 2008 Tungsten Graphics, Inc. |
| This program is free software: you can redistribute it and/or modify it |
| under the terms of the GNU Lesser General Public License as published |
| by the Free Software Foundation, either version 3 of the License, or |
| (at your option) any later version. |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU Lesser General Public License for more details. |
| You should have received a copy of the GNU Lesser General Public License |
| along with this program. If not, see <http://www.gnu.org/licenses/>. |
| !--> |
| <xsl:transform version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> |
| <xsl:output method="html" /> |
| <xsl:strip-space elements="*" /> |
| <xsl:template match="/trace"> |
| <html> |
| <head> |
| <title>Gallium Trace</title> |
| </head> |
| <style> |
| body { |
| font-family: verdana, sans-serif; |
| font-size: 11px; |
| font-weight: normal; |
| text-align : left; |
| } |
| .fun { |
| font-weight: bold; |
| } |
| .var { |
| font-style: italic; |
| } |
| .typ { |
| display: none; |
| } |
| .lit { |
| color: #0000ff; |
| } |
| .ptr { |
| color: #008000; |
| } |
| </style> |
| <body> |
| <ol class="calls"> |
| <xsl:apply-templates/> |
| </ol> |
| </body> |
| </html> |
| </xsl:template> |
| <xsl:template match="call"> |
| <li> |
| <xsl:attribute name="value"> |
| <xsl:apply-templates select="@no"/> |
| </xsl:attribute> |
| <span class="fun"> |
| <xsl:value-of select="@class"/> |
| <xsl:text>::</xsl:text> |
| <xsl:value-of select="@method"/> |
| </span> |
| <xsl:text>(</xsl:text> |
| <xsl:apply-templates select="arg"/> |
| <xsl:text>)</xsl:text> |
| <xsl:apply-templates select="ret"/> |
| </li> |
| </xsl:template> |
| <xsl:template match="arg|member"> |
| <xsl:apply-templates select="@name"/> |
| <xsl:text> = </xsl:text> |
| <xsl:apply-templates /> |
| <xsl:if test="position() != last()"> |
| <xsl:text>, </xsl:text> |
| </xsl:if> |
| </xsl:template> |
| <xsl:template match="ret"> |
| <xsl:text> = </xsl:text> |
| <xsl:apply-templates /> |
| </xsl:template> |
| <xsl:template match="bool|int|uint|float|enum"> |
| <span class="lit"> |
| <xsl:value-of select="text()"/> |
| </span> |
| </xsl:template> |
| <xsl:template match="bytes"> |
| <span class="lit"> |
| <xsl:text>...</xsl:text> |
| </span> |
| </xsl:template> |
| <xsl:template match="string"> |
| <span class="lit"> |
| <xsl:text>"</xsl:text> |
| <xsl:call-template name="break"> |
| <xsl:with-param name="text" select="text()"/> |
| </xsl:call-template> |
| <xsl:text>"</xsl:text> |
| </span> |
| </xsl:template> |
| <xsl:template match="array|struct"> |
| <xsl:text>{</xsl:text> |
| <xsl:apply-templates /> |
| <xsl:text>}</xsl:text> |
| </xsl:template> |
| <xsl:template match="elem"> |
| <xsl:apply-templates /> |
| <xsl:if test="position() != last()"> |
| <xsl:text>, </xsl:text> |
| </xsl:if> |
| </xsl:template> |
| <xsl:template match="null"> |
| <span class="ptr"> |
| <xsl:text>NULL</xsl:text> |
| </span> |
| </xsl:template> |
| <xsl:template match="ptr"> |
| <span class="ptr"> |
| <xsl:value-of select="text()"/> |
| </span> |
| </xsl:template> |
| <xsl:template match="@name"> |
| <span class="var"> |
| <xsl:value-of select="."/> |
| </span> |
| </xsl:template> |
| <xsl:template name="break"> |
| <xsl:param name="text" select="."/> |
| <xsl:choose> |
| <xsl:when test="contains($text, '
')"> |
| <xsl:value-of select="substring-before($text, '
')"/> |
| <br/> |
| <xsl:call-template name="break"> |
| <xsl:with-param name="text" select="substring-after($text, '
')"/> |
| </xsl:call-template> |
| </xsl:when> |
| <xsl:otherwise> |
| <xsl:value-of select="$text"/> |
| </xsl:otherwise> |
| </xsl:choose> |
| </xsl:template> |
| <xsl:template name="replace"> |
| <xsl:param name="text"/> |
| <xsl:param name="from"/> |
| <xsl:param name="to"/> |
| <xsl:choose> |
| <xsl:when test="contains($text,$from)"> |
| <xsl:value-of select="concat(substring-before($text,$from),$to)"/> |
| <xsl:call-template name="replace"> |
| <xsl:with-param name="text" select="substring-after($text,$from)"/> |
| <xsl:with-param name="from" select="$from"/> |
| <xsl:with-param name="to" select="$to"/> |
| </xsl:call-template> |
| </xsl:when> |
| <xsl:otherwise> |
| <xsl:value-of select="$text"/> |
| </xsl:otherwise> |
| </xsl:choose> |
| </xsl:template> |
| </xsl:transform> |