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 struct pipe_surface * trace_winsys_surface_alloc(struct pipe_winsys *_winsys) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; struct pipe_surface *result; trace_dump_call_begin("pipe_winsys", "surface_alloc"); trace_dump_arg(ptr, winsys); result = winsys->surface_alloc(winsys); trace_dump_ret(ptr, result); trace_dump_call_end(); assert(!result || !result->texture); return result; }
static int trace_screen_get_param(struct pipe_screen *_screen, int 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 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 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 unsigned int trace_is_buffer_referenced( struct pipe_context *_pipe, struct pipe_buffer *_buf) { struct trace_context *tr_ctx = trace_context(_pipe); struct trace_buffer *tr_buf = trace_buffer(_buf); struct pipe_context *pipe = tr_ctx->pipe; struct pipe_buffer *buf = tr_buf->buffer; unsigned int referenced; trace_dump_call_begin("pipe_context", "is_buffer_referenced"); trace_dump_arg(ptr, pipe); trace_dump_arg(ptr, buf); referenced = pipe->is_buffer_referenced(pipe, buf); trace_dump_ret(uint, referenced); trace_dump_call_end(); return referenced; }
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 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 INLINE void trace_context_set_vertex_elements(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; trace_dump_call_begin("pipe_context", "set_vertex_elements"); 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(); pipe->set_vertex_elements(pipe, num_elements, elements); 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; { tr_ctx->curr.nr_cbufs = state->nr_cbufs; for (i = 0; i < state->nr_cbufs; i++) if (state->cbufs[i]) tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture); else tr_ctx->curr.cbufs[i] = NULL; if (state->zsbuf) tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture); else tr_ctx->curr.zsbuf = NULL; } /* 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 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 INLINE void trace_context_clear(struct pipe_context *_pipe, unsigned buffers, const float *rgba, 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_array(float, rgba, 4); trace_dump_arg(float, depth); trace_dump_arg(uint, stencil); pipe->clear(pipe, buffers, rgba, depth, stencil); trace_dump_call_end(); }
static void trace_screen_flush_frontbuffer(struct pipe_screen *_screen, struct pipe_surface *_surface, void *context_private) { struct trace_screen *tr_scr = trace_screen(_screen); struct trace_surface *tr_surf = trace_surface(_surface); struct pipe_screen *screen = tr_scr->screen; struct pipe_surface *surface = tr_surf->surface; trace_dump_call_begin("pipe_screen", "flush_frontbuffer"); trace_dump_arg(ptr, screen); trace_dump_arg(ptr, surface); /* XXX: hide, as there is nothing we can do with this trace_dump_arg(ptr, context_private); */ screen->flush_frontbuffer(screen, surface, context_private); trace_dump_call_end(); }
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 int trace_screen_get_compute_param(struct pipe_screen *_screen, enum pipe_compute_cap param, void *data) { struct trace_screen *tr_scr = trace_screen(_screen); struct pipe_screen *screen = tr_scr->screen; int result; trace_dump_call_begin("pipe_screen", "get_compute_param"); trace_dump_arg(ptr, screen); trace_dump_arg(int, param); trace_dump_arg(ptr, data); result = screen->get_compute_param(screen, param, data); trace_dump_ret(int, result); trace_dump_call_end(); return result; }
static INLINE boolean trace_context_draw_elements(struct pipe_context *_pipe, struct pipe_buffer *_indexBuffer, unsigned indexSize, unsigned mode, unsigned start, unsigned count) { struct trace_context *tr_ctx = trace_context(_pipe); struct trace_buffer *tr_buf = trace_buffer(_indexBuffer); struct pipe_context *pipe = tr_ctx->pipe; struct pipe_buffer *indexBuffer = tr_buf->buffer; boolean result; if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled) return 0; trace_context_draw_block(tr_ctx, 1); trace_screen_user_buffer_update(_pipe->screen, indexBuffer); trace_dump_call_begin("pipe_context", "draw_elements"); trace_dump_arg(ptr, pipe); trace_dump_arg(ptr, indexBuffer); trace_dump_arg(uint, indexSize); trace_dump_arg(uint, mode); trace_dump_arg(uint, start); trace_dump_arg(uint, count); result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);; trace_dump_ret(bool, result); trace_dump_call_end(); trace_context_draw_block(tr_ctx, 2); return result; }
static int trace_winsys_fence_finish(struct pipe_winsys *_winsys, struct pipe_fence_handle *fence, unsigned flag) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; int result; trace_dump_call_begin("pipe_winsys", "fence_finish"); trace_dump_arg(ptr, winsys); trace_dump_arg(ptr, fence); trace_dump_arg(uint, flag); result = winsys->fence_finish(winsys, fence, flag); trace_dump_ret(int, result); trace_dump_call_end(); return result; }
static INLINE void * trace_context_create_vs_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_vs_state"); trace_dump_arg(ptr, pipe); trace_dump_arg(shader_state, state); result = pipe->create_vs_state(pipe, state); trace_dump_ret(ptr, result); trace_dump_call_end(); result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX); return result; }
static INLINE void trace_context_bind_vs_state(struct pipe_context *_pipe, void *_state) { struct trace_context *tr_ctx = trace_context(_pipe); struct trace_shader *tr_shdr = trace_shader(_state); struct pipe_context *pipe = tr_ctx->pipe; void *state = tr_shdr ? tr_shdr->state : NULL; trace_dump_call_begin("pipe_context", "bind_vs_state"); trace_dump_arg(ptr, pipe); trace_dump_arg(ptr, state); tr_ctx->curr.vs = tr_shdr; if (tr_shdr && tr_shdr->replaced) state = tr_shdr->replaced; pipe->bind_vs_state(pipe, state); trace_dump_call_end(); }
static int trace_screen_fence_finish(struct pipe_screen *_screen, struct pipe_fence_handle *fence, unsigned flags) { 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, flags); result = screen->fence_finish(screen, fence, flags); trace_dump_ret(int, 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; }
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 int trace_winsys_surface_alloc_storage(struct pipe_winsys *_winsys, struct pipe_surface *surface, unsigned width, unsigned height, enum pipe_format format, unsigned flags, unsigned tex_usage) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; int result; assert(surface && !surface->texture); trace_dump_call_begin("pipe_winsys", "surface_alloc_storage"); trace_dump_arg(ptr, winsys); trace_dump_arg(ptr, surface); trace_dump_arg(uint, width); trace_dump_arg(uint, height); trace_dump_arg(format, format); trace_dump_arg(uint, flags); trace_dump_arg(uint, tex_usage); result = winsys->surface_alloc_storage(winsys, surface, width, height, format, flags, tex_usage); trace_dump_ret(int, result); trace_dump_call_end(); return result; }
static unsigned int trace_is_texture_referenced( struct pipe_context *_pipe, struct pipe_texture *_texture, unsigned face, unsigned level) { struct trace_context *tr_ctx = trace_context(_pipe); struct trace_texture *tr_tex = trace_texture(_texture); struct pipe_context *pipe = tr_ctx->pipe; struct pipe_texture *texture = tr_tex->texture; unsigned int referenced; trace_dump_call_begin("pipe_context", "is_texture_referenced"); trace_dump_arg(ptr, pipe); trace_dump_arg(ptr, texture); trace_dump_arg(uint, face); trace_dump_arg(uint, level); referenced = pipe->is_texture_referenced(pipe, texture, face, level); trace_dump_ret(uint, referenced); trace_dump_call_end(); return referenced; }
static INLINE void trace_context_set_constant_buffer(struct pipe_context *_pipe, uint shader, uint index, struct pipe_buffer *buffer) { struct trace_context *tr_ctx = trace_context(_pipe); struct pipe_context *pipe = tr_ctx->pipe; if (buffer) { trace_screen_user_buffer_update(_pipe->screen, buffer); buffer = trace_buffer_unwrap(tr_ctx, buffer); } 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(ptr, buffer); pipe->set_constant_buffer(pipe, shader, index, buffer); trace_dump_call_end(); }
struct pipe_context * trace_context_create(struct pipe_screen *_screen, struct pipe_context *pipe) { struct trace_screen *tr_scr; struct trace_context *tr_ctx; struct pipe_screen *screen; if(!pipe) goto error1; if(!trace_enabled()) goto error1; tr_scr = trace_screen(_screen); screen = tr_scr->screen; tr_ctx = CALLOC_STRUCT(trace_context); if(!tr_ctx) goto error1; tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK", rbug_blocker_flags, 0); pipe_mutex_init(tr_ctx->draw_mutex); pipe_condvar_init(tr_ctx->draw_cond); pipe_mutex_init(tr_ctx->list_mutex); make_empty_list(&tr_ctx->shaders); tr_ctx->base.winsys = _screen->winsys; tr_ctx->base.screen = _screen; tr_ctx->base.destroy = trace_context_destroy; tr_ctx->base.set_edgeflags = trace_context_set_edgeflags; tr_ctx->base.draw_arrays = trace_context_draw_arrays; tr_ctx->base.draw_elements = trace_context_draw_elements; tr_ctx->base.draw_range_elements = trace_context_draw_range_elements; tr_ctx->base.create_query = trace_context_create_query; tr_ctx->base.destroy_query = trace_context_destroy_query; tr_ctx->base.begin_query = trace_context_begin_query; tr_ctx->base.end_query = trace_context_end_query; tr_ctx->base.get_query_result = trace_context_get_query_result; tr_ctx->base.create_blend_state = trace_context_create_blend_state; tr_ctx->base.bind_blend_state = trace_context_bind_blend_state; tr_ctx->base.delete_blend_state = trace_context_delete_blend_state; tr_ctx->base.create_sampler_state = trace_context_create_sampler_state; tr_ctx->base.bind_sampler_states = trace_context_bind_sampler_states; tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state; tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state; tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state; tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state; tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state; tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state; tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state; tr_ctx->base.create_fs_state = trace_context_create_fs_state; tr_ctx->base.bind_fs_state = trace_context_bind_fs_state; tr_ctx->base.delete_fs_state = trace_context_delete_fs_state; tr_ctx->base.create_vs_state = trace_context_create_vs_state; tr_ctx->base.bind_vs_state = trace_context_bind_vs_state; tr_ctx->base.delete_vs_state = trace_context_delete_vs_state; tr_ctx->base.set_blend_color = trace_context_set_blend_color; tr_ctx->base.set_clip_state = trace_context_set_clip_state; tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer; tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state; tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple; tr_ctx->base.set_scissor_state = trace_context_set_scissor_state; tr_ctx->base.set_viewport_state = trace_context_set_viewport_state; tr_ctx->base.set_sampler_textures = trace_context_set_sampler_textures; tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers; tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements; if (pipe->surface_copy) tr_ctx->base.surface_copy = trace_context_surface_copy; if (pipe->surface_fill) tr_ctx->base.surface_fill = trace_context_surface_fill; tr_ctx->base.clear = trace_context_clear; tr_ctx->base.flush = trace_context_flush; tr_ctx->base.is_texture_referenced = trace_is_texture_referenced; tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced; tr_ctx->pipe = pipe; trace_dump_call_begin("", "pipe_context_create"); trace_dump_arg(ptr, screen); trace_dump_ret(ptr, pipe); trace_dump_call_end(); trace_screen_add_to_list(tr_scr, contexts, tr_ctx); return &tr_ctx->base; error1: return pipe; }
struct pipe_screen * trace_screen_create(struct pipe_screen *screen) { struct trace_screen *tr_scr; struct pipe_winsys *winsys; 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; #if 0 winsys = trace_winsys_create(screen->winsys); if(!winsys) goto error3; #else winsys = screen->winsys; #endif tr_scr->base.winsys = winsys; 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.get_tex_surface = trace_screen_get_tex_surface; tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy; tr_scr->base.user_buffer_create = trace_screen_user_buffer_create; 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->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(); trace_dump_trace_end(); error1: return screen; }