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