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;
}
