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; }
static struct pipe_buffer * trace_winsys_user_buffer_create(struct pipe_winsys *_winsys, void *data, unsigned size) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; struct pipe_buffer *result; trace_dump_call_begin("pipe_winsys", "user_buffer_create"); trace_dump_arg(ptr, winsys); trace_dump_arg_begin("data"); trace_dump_bytes(data, size); trace_dump_arg_end(); trace_dump_arg(uint, size); result = winsys->user_buffer_create(winsys, data, size); trace_dump_ret(ptr, result); trace_dump_call_end(); /* XXX: Mark the user buffers. (we should wrap pipe_buffers, but is is * impossible to do so while texture-less surfaces are still around */ if(result) { assert(!(result->usage & TRACE_BUFFER_USAGE_USER)); result->usage |= TRACE_BUFFER_USAGE_USER; } return result; }
static struct pipe_buffer * trace_winsys_buffer_create(struct pipe_winsys *_winsys, unsigned alignment, unsigned usage, unsigned size) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; struct pipe_buffer *buffer; trace_dump_call_begin("pipe_winsys", "buffer_create"); trace_dump_arg(ptr, winsys); trace_dump_arg(uint, alignment); trace_dump_arg(uint, usage); trace_dump_arg(uint, size); buffer = winsys->buffer_create(winsys, alignment, usage, size); trace_dump_ret(ptr, buffer); trace_dump_call_end(); /* Zero the buffer to avoid dumping uninitialized memory */ if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) { void *map; map = winsys->buffer_map(winsys, buffer, PIPE_BUFFER_USAGE_CPU_WRITE); if(map) { memset(map, 0, buffer->size); winsys->buffer_unmap(winsys, buffer); } } return buffer; }
static struct pipe_resource * trace_screen_user_buffer_create(struct pipe_screen *_screen, void *data, unsigned size, unsigned usage) { 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", "user_buffer_create"); trace_dump_arg(ptr, screen); trace_dump_arg_begin("data"); trace_dump_bytes(data, size); trace_dump_arg_end(); trace_dump_arg(uint, size); trace_dump_arg(uint, usage); result = screen->user_buffer_create(screen, data, size, usage); trace_dump_ret(ptr, result); trace_dump_call_end(); if(result) { assert(!(result->flags & TRACE_FLAG_USER_BUFFER)); result->flags |= TRACE_FLAG_USER_BUFFER; } return trace_resource_create(tr_scr, result); }
static struct pipe_surface * trace_screen_get_tex_surface(struct pipe_screen *_screen, struct pipe_resource *_texture, unsigned face, unsigned level, unsigned zslice, unsigned usage) { struct trace_screen *tr_scr = trace_screen(_screen); struct trace_resource *tr_tex = trace_resource(_texture); struct pipe_screen *screen = tr_scr->screen; struct pipe_resource *texture = tr_tex->resource; struct pipe_surface *result = NULL; assert(texture->screen == screen); trace_dump_call_begin("pipe_screen", "get_tex_surface"); trace_dump_arg(ptr, screen); trace_dump_arg(ptr, texture); trace_dump_arg(uint, face); trace_dump_arg(uint, level); trace_dump_arg(uint, zslice); trace_dump_arg(uint, usage); result = screen->get_tex_surface(screen, texture, face, level, zslice, usage); trace_dump_ret(ptr, result); trace_dump_call_end(); result = trace_surface_create(tr_tex, result); return result; }
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; }
struct pipe_winsys * trace_winsys_create(struct pipe_winsys *winsys) { struct trace_winsys *tr_ws; if(!winsys) goto error1; tr_ws = CALLOC_STRUCT(trace_winsys); if(!tr_ws) goto error1; tr_ws->base.destroy = trace_winsys_destroy; tr_ws->base.get_name = trace_winsys_get_name; tr_ws->base.flush_frontbuffer = trace_winsys_flush_frontbuffer; tr_ws->base.surface_alloc = trace_winsys_surface_alloc; tr_ws->base.surface_alloc_storage = trace_winsys_surface_alloc_storage; tr_ws->base.surface_release = trace_winsys_surface_release; tr_ws->base.buffer_create = trace_winsys_buffer_create; tr_ws->base.user_buffer_create = trace_winsys_user_buffer_create; tr_ws->base.buffer_map = trace_winsys_buffer_map; tr_ws->base.buffer_unmap = trace_winsys_buffer_unmap; tr_ws->base.buffer_destroy = trace_winsys_buffer_destroy; tr_ws->base.fence_reference = trace_winsys_fence_reference; tr_ws->base.fence_signalled = trace_winsys_fence_signalled; tr_ws->base.fence_finish = trace_winsys_fence_finish; tr_ws->winsys = winsys; tr_ws->buffer_maps = hash_table_create(trace_buffer_hash, trace_buffer_compare); if(!tr_ws->buffer_maps) goto error2; trace_dump_call_begin("", "pipe_winsys_create"); trace_dump_ret(ptr, winsys); trace_dump_call_end(); return &tr_ws->base; error2: FREE(tr_ws); error1: return winsys; }
static const char * trace_winsys_get_name(struct pipe_winsys *_winsys) { struct trace_winsys *tr_ws = trace_winsys(_winsys); struct pipe_winsys *winsys = tr_ws->winsys; const char *result; trace_dump_call_begin("pipe_winsys", "get_name"); trace_dump_arg(ptr, winsys); result = winsys->get_name(winsys); 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 INLINE void trace_context_flush(struct pipe_context *_pipe, unsigned flags, struct pipe_fence_handle **fence) { 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, flags, fence); if(fence) trace_dump_ret(ptr, *fence); 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 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 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 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 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 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 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; }
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; }