X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Ftrace%2Ftr_context.c;h=f8637bd599d26a4c26f11403a4badf0864d4d85a;hb=b0fc2f13eceb525056597c6a9191d2ad81773a4c;hp=5c24bd1f7dfcc3316ecdbd61c49ef4b10d0cdb35;hpb=182c42c8da6edfa66819eef02f4dea310c1f68d7;p=mesa.git diff --git a/src/gallium/drivers/trace/tr_context.c b/src/gallium/drivers/trace/tr_context.c index 5c24bd1f7df..f8637bd599d 100644 --- a/src/gallium/drivers/trace/tr_context.c +++ b/src/gallium/drivers/trace/tr_context.c @@ -28,51 +28,34 @@ #include "util/u_inlines.h" #include "util/u_memory.h" #include "util/u_simple_list.h" -#include "util/u_format.h" #include "pipe/p_format.h" #include "pipe/p_screen.h" #include "tr_dump.h" #include "tr_dump_state.h" -#include "tr_state.h" -#include "tr_buffer.h" +#include "tr_public.h" #include "tr_screen.h" #include "tr_texture.h" +#include "tr_context.h" -static INLINE struct pipe_buffer * -trace_buffer_unwrap(struct trace_context *tr_ctx, - struct pipe_buffer *buffer) -{ - struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen); - struct trace_buffer *tr_buf; - - if(!buffer) - return NULL; - tr_buf = trace_buffer(buffer); - assert(tr_buf->buffer); - assert(tr_buf->buffer->screen == tr_scr->screen); - (void) tr_scr; - return tr_buf->buffer; -} - -static INLINE struct pipe_texture * -trace_texture_unwrap(struct trace_context *tr_ctx, - struct pipe_texture *texture) +static INLINE struct pipe_resource * +trace_resource_unwrap(struct trace_context *tr_ctx, + struct pipe_resource *resource) { - struct trace_texture *tr_tex; + struct trace_resource *tr_res; - if(!texture) + if(!resource) return NULL; - tr_tex = trace_texture(texture); + tr_res = trace_resource(resource); - assert(tr_tex->texture); - return tr_tex->texture; + assert(tr_res->resource); + return tr_res->resource; } @@ -100,173 +83,22 @@ trace_surface_unwrap(struct trace_context *tr_ctx, static INLINE void -trace_context_draw_block(struct trace_context *tr_ctx, int flag) -{ - int k; - - pipe_mutex_lock(tr_ctx->draw_mutex); - - if (tr_ctx->draw_blocker & flag) { - tr_ctx->draw_blocked |= flag; - } else if ((tr_ctx->draw_rule.blocker & flag) && - (tr_ctx->draw_blocker & 4)) { - boolean block = FALSE; - debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__, - (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs, - (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs, - (void *) tr_ctx->draw_rule.surf, 0, - (void *) tr_ctx->draw_rule.sampler_view, 0); - if (tr_ctx->draw_rule.fs && - tr_ctx->draw_rule.fs == tr_ctx->curr.fs) - block = TRUE; - if (tr_ctx->draw_rule.vs && - tr_ctx->draw_rule.vs == tr_ctx->curr.vs) - block = TRUE; - if (tr_ctx->draw_rule.surf && - tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf) - block = TRUE; - if (tr_ctx->draw_rule.surf) - for (k = 0; k < tr_ctx->curr.nr_cbufs; k++) - if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k]) - block = TRUE; - if (tr_ctx->draw_rule.sampler_view) { - for (k = 0; k < tr_ctx->curr.num_sampler_views; k++) - if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.sampler_views[k]) - block = TRUE; - for (k = 0; k < tr_ctx->curr.num_vert_sampler_views; k++) { - if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.vert_sampler_views[k]) { - block = TRUE; - } - } - } - - if (block) - tr_ctx->draw_blocked |= (flag | 4); - } - - if (tr_ctx->draw_blocked) - trace_rbug_notify_draw_blocked(tr_ctx); - - /* wait for rbug to clear the blocked flag */ - while (tr_ctx->draw_blocked & flag) { - tr_ctx->draw_blocked |= flag; -#ifdef PIPE_THREAD_HAVE_CONDVAR - pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex); -#else - pipe_mutex_unlock(tr_ctx->draw_mutex); -#ifdef PIPE_SUBSYSTEM_WINDOWS_USER - Sleep(1); -#endif - pipe_mutex_lock(tr_ctx->draw_mutex); -#endif - } - - pipe_mutex_unlock(tr_ctx->draw_mutex); -} - -static INLINE void -trace_context_draw_arrays(struct pipe_context *_pipe, - unsigned mode, unsigned start, unsigned count) -{ - struct trace_context *tr_ctx = trace_context(_pipe); - struct pipe_context *pipe = tr_ctx->pipe; - - if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled) - return; - - trace_context_draw_block(tr_ctx, 1); - - trace_dump_call_begin("pipe_context", "draw_arrays"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(uint, mode); - trace_dump_arg(uint, start); - trace_dump_arg(uint, count); - - pipe->draw_arrays(pipe, mode, start, count); - - trace_dump_call_end(); - - trace_context_draw_block(tr_ctx, 2); -} - - -static INLINE void -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; - - if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled) - return; - - 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); - - pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count); - - trace_dump_call_end(); - - trace_context_draw_block(tr_ctx, 2); -} - - -static INLINE void -trace_context_draw_range_elements(struct pipe_context *_pipe, - struct pipe_buffer *_indexBuffer, - unsigned indexSize, - unsigned minIndex, - unsigned maxIndex, - unsigned mode, - unsigned start, - unsigned count) +trace_context_draw_vbo(struct pipe_context *_pipe, + const struct pipe_draw_info *info) { 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; - if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled) - return; + trace_dump_call_begin("pipe_context", "draw_vbo"); - trace_context_draw_block(tr_ctx, 1); + trace_dump_arg(ptr, pipe); + trace_dump_arg(draw_info, info); - trace_screen_user_buffer_update(_pipe->screen, indexBuffer); + trace_dump_trace_flush(); - trace_dump_call_begin("pipe_context", "draw_range_elements"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(ptr, indexBuffer); - trace_dump_arg(uint, indexSize); - trace_dump_arg(uint, minIndex); - trace_dump_arg(uint, maxIndex); - trace_dump_arg(uint, mode); - trace_dump_arg(uint, start); - trace_dump_arg(uint, count); - - pipe->draw_range_elements(pipe, - indexBuffer, - indexSize, minIndex, maxIndex, - mode, start, count); + pipe->draw_vbo(pipe, info); trace_dump_call_end(); - - trace_context_draw_block(tr_ctx, 2); } @@ -351,7 +183,7 @@ static INLINE boolean trace_context_get_query_result(struct pipe_context *_pipe, struct pipe_query *query, boolean wait, - uint64_t *presult) + union pipe_query_result *presult) { struct trace_context *tr_ctx = trace_context(_pipe); struct pipe_context *pipe = tr_ctx->pipe; @@ -363,7 +195,8 @@ trace_context_get_query_result(struct pipe_context *_pipe, trace_dump_arg(ptr, pipe); _result = pipe->get_query_result(pipe, query, wait, presult); - result = *presult; + /* XXX this depends on the query type */ + result = *((uint64_t*)presult); trace_dump_arg(uint, result); trace_dump_ret(bool, _result); @@ -457,42 +290,81 @@ trace_context_create_sampler_state(struct pipe_context *_pipe, static INLINE void -trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe, - unsigned num_states, - void **states) +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; - trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states"); + /* 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); - pipe->bind_fragment_sampler_states(pipe, num_states, 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_vertex_sampler_states(struct pipe_context *_pipe, - unsigned num_states, - void **states) +trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe, + unsigned num, + void **states) { - struct trace_context *tr_ctx = trace_context(_pipe); - struct pipe_context *pipe = tr_ctx->pipe; + trace_context_bind_sampler_states(_pipe, PIPE_SHADER_FRAGMENT, + 0, num, states); +} - trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states"); - trace_dump_arg(ptr, pipe); - trace_dump_arg(uint, num_states); - trace_dump_arg_array(ptr, states, 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); +} - pipe->bind_vertex_sampler_states(pipe, num_states, states); - trace_dump_call_end(); +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); } @@ -632,148 +504,54 @@ trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe, } -static INLINE void * -trace_context_create_fs_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_fs_state"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(shader_state, state); - - result = pipe->create_fs_state(pipe, state); - - trace_dump_ret(ptr, result); - - trace_dump_call_end(); - - result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT); - - return result; -} - - -static INLINE void -trace_context_bind_fs_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_fs_state"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(ptr, state); - - tr_ctx->curr.fs = tr_shdr; - - if (tr_shdr && tr_shdr->replaced) - state = tr_shdr->replaced; - - pipe->bind_fs_state(pipe, state); - - trace_dump_call_end(); -} - - -static INLINE void -trace_context_delete_fs_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->state; - - trace_dump_call_begin("pipe_context", "delete_fs_state"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(ptr, state); - - pipe->delete_fs_state(pipe, state); - - trace_dump_call_end(); - - trace_shader_destroy(tr_ctx, tr_shdr); -} - - -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 INLINE void -trace_context_delete_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->state; - - trace_dump_call_begin("pipe_context", "delete_vs_state"); - - trace_dump_arg(ptr, pipe); - trace_dump_arg(ptr, state); - - pipe->delete_vs_state(pipe, state); +#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_dump_call_end(); +TRACE_SHADER_STATE(fs) +TRACE_SHADER_STATE(vs) +TRACE_SHADER_STATE(gs) - trace_shader_destroy(tr_ctx, tr_shdr); -} +#undef TRACE_SHADER_STATE static INLINE void * @@ -829,7 +607,7 @@ trace_context_delete_vertex_elements_state(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", "delete_verte_elements_state"); + trace_dump_call_begin("pipe_context", "delete_vertex_elements_state"); trace_dump_arg(ptr, pipe); trace_dump_arg(ptr, state); @@ -893,18 +671,36 @@ trace_context_set_clip_state(struct pipe_context *_pipe, 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_buffer *buffer) + 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 (buffer) { - trace_screen_user_buffer_update(_pipe->screen, buffer); - buffer = trace_buffer_unwrap(tr_ctx, buffer); + 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"); @@ -912,9 +708,9 @@ trace_context_set_constant_buffer(struct pipe_context *_pipe, trace_dump_arg(ptr, pipe); trace_dump_arg(uint, shader); trace_dump_arg(uint, index); - trace_dump_arg(ptr, buffer); + trace_dump_arg(constant_buffer, constant_buffer); - pipe->set_constant_buffer(pipe, shader, index, buffer); + pipe->set_constant_buffer(pipe, shader, index, constant_buffer); trace_dump_call_end(); } @@ -929,18 +725,6 @@ trace_context_set_framebuffer_state(struct pipe_context *_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)); @@ -1017,40 +801,50 @@ trace_context_set_viewport_state(struct pipe_context *_pipe, static struct pipe_sampler_view * -trace_create_sampler_view(struct pipe_context *_pipe, - struct pipe_texture *_texture, +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_texture *tr_tex = trace_texture(_texture); + struct trace_resource *tr_res = trace_resource(_resource); struct pipe_context *pipe = tr_ctx->pipe; - struct pipe_texture *texture = tr_tex->texture; - struct trace_sampler_view *result = CALLOC_STRUCT(trace_sampler_view); + 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, texture); - trace_dump_arg(ptr, templ); + trace_dump_arg(ptr, resource); - result->sampler_view = pipe->create_sampler_view(pipe, texture, templ); + trace_dump_arg_begin("templ"); + trace_dump_sampler_view_template(templ, resource->target); + trace_dump_arg_end(); - result->base = *templ; - result->base.reference.count = 1; - result->base.texture = NULL; - pipe_texture_reference(&result->base.texture, _texture); - result->base.context = _pipe; + result = pipe->create_sampler_view(pipe, resource, templ); trace_dump_ret(ptr, result); trace_dump_call_end(); - return &result->base; + /* + * 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_sampler_view_destroy(struct pipe_context *_pipe, +trace_context_sampler_view_destroy(struct pipe_context *_pipe, struct pipe_sampler_view *_view) { struct trace_context *tr_ctx = trace_context(_pipe); @@ -1058,112 +852,193 @@ trace_sampler_view_destroy(struct pipe_context *_pipe, 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_destroy(pipe, view); + pipe_sampler_view_reference(&tr_view->sampler_view, NULL); trace_dump_call_end(); - pipe_texture_reference(&_view->texture, NULL); + pipe_resource_reference(&_view->texture, NULL); FREE(_view); } +/******************************************************************** + * surface + */ -static INLINE void -trace_context_set_fragment_sampler_views(struct pipe_context *_pipe, - unsigned num, - struct pipe_sampler_view **views) + +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_sampler_view *tr_view; + struct trace_resource *tr_res = trace_resource(_resource); struct pipe_context *pipe = tr_ctx->pipe; - struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS]; - unsigned i; + struct pipe_resource *resource = tr_res->resource; + struct pipe_surface *result = NULL; - tr_ctx->curr.num_sampler_views = num; - for(i = 0; i < num; ++i) { - tr_view = trace_sampler_view(views[i]); - tr_ctx->curr.sampler_views[i] = tr_view; - unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL; - } - views = unwrapped_views; - - trace_dump_call_begin("pipe_context", "set_fragment_sampler_views"); + trace_dump_call_begin("pipe_context", "create_surface"); trace_dump_arg(ptr, pipe); - trace_dump_arg(uint, num); - trace_dump_arg_array(ptr, views, num); + trace_dump_arg(ptr, resource); + + trace_dump_arg_begin("surf_tmpl"); + trace_dump_surface_template(surf_tmpl, resource->target); + trace_dump_arg_end(); + - pipe->set_fragment_sampler_views(pipe, num, views); + 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_vertex_sampler_views(struct pipe_context *_pipe, - unsigned num, - struct pipe_sampler_view **views) +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_VERTEX_SAMPLERS]; + struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS]; unsigned i; - tr_ctx->curr.num_vert_sampler_views = num; + /* 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]); - tr_ctx->curr.vert_sampler_views[i] = tr_view; unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL; } views = unwrapped_views; - trace_dump_call_begin("pipe_context", "set_vertex_sampler_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); - pipe->set_vertex_sampler_views(pipe, num, views); + 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 num_buffers, + 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; - for(i = 0; i < num_buffers; ++i) - trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer); - 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 (num_buffers) { - struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers)); + 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_buffer_unwrap(tr_ctx, buffers[i].buffer); - pipe->set_vertex_buffers(pipe, num_buffers, _buffers); - free(_buffers); + _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, num_buffers, NULL); + pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL); } trace_dump_call_end(); @@ -1171,61 +1046,151 @@ trace_context_set_vertex_buffers(struct pipe_context *_pipe, static INLINE void -trace_context_surface_copy(struct pipe_context *_pipe, - struct pipe_surface *dest, - unsigned destx, unsigned desty, - struct pipe_surface *src, - unsigned srcx, unsigned srcy, - unsigned width, unsigned height) +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; - dest = trace_surface_unwrap(tr_ctx, dest); - src = trace_surface_unwrap(tr_ctx, src); + 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(); +} - trace_dump_call_begin("pipe_context", "surface_copy"); + +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, dest); - trace_dump_arg(uint, destx); - trace_dump_arg(uint, desty); - trace_dump_arg(ptr, src); - trace_dump_arg(uint, srcx); - trace_dump_arg(uint, srcy); - trace_dump_arg(uint, width); - trace_dump_arg(uint, height); + trace_dump_arg(ptr, res); + trace_dump_arg(uint, buffer_offset); + trace_dump_arg(uint, buffer_size); - pipe->surface_copy(pipe, - dest, destx, desty, - src, srcx, srcy, width, height); + result = pipe->create_stream_output_target(pipe, + res, buffer_offset, buffer_size); trace_dump_call_end(); + + return result; } static INLINE void -trace_context_surface_fill(struct pipe_context *_pipe, - struct pipe_surface *dst, - unsigned dstx, unsigned dsty, - unsigned width, unsigned height, - unsigned value) +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; - dst = trace_surface_unwrap(tr_ctx, dst); + trace_dump_call_begin("pipe_context", "stream_output_target_destroy"); + + trace_dump_arg(ptr, pipe); + trace_dump_arg(ptr, target); - trace_dump_call_begin("pipe_context", "surface_fill"); + 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, width); - trace_dump_arg(uint, height); + trace_dump_arg(uint, dstz); + trace_dump_arg(ptr, src); + trace_dump_arg(uint, src_level); + trace_dump_arg(box, src_box); - pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value); + 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(); } @@ -1234,7 +1199,7 @@ trace_context_surface_fill(struct pipe_context *_pipe, static INLINE void trace_context_clear(struct pipe_context *_pipe, unsigned buffers, - const float *rgba, + const union pipe_color_union *color, double depth, unsigned stencil) { @@ -1245,101 +1210,115 @@ trace_context_clear(struct pipe_context *_pipe, trace_dump_arg(ptr, pipe); trace_dump_arg(uint, buffers); - trace_dump_arg_array(float, rgba, 4); + 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, rgba, depth, stencil); + pipe->clear(pipe, buffers, color, depth, stencil); trace_dump_call_end(); } static INLINE void -trace_context_flush(struct pipe_context *_pipe, - unsigned flags, - struct pipe_fence_handle **fence) +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; - trace_dump_call_begin("pipe_context", "flush"); + dst = trace_surface_unwrap(tr_ctx, dst); + + trace_dump_call_begin("pipe_context", "clear_render_target"); trace_dump_arg(ptr, pipe); - trace_dump_arg(uint, flags); + 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->flush(pipe, flags, fence); - - if(fence) - trace_dump_ret(ptr, *fence); + pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height); trace_dump_call_end(); } - static INLINE void -trace_context_destroy(struct pipe_context *_pipe) +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_screen *tr_scr = trace_screen(_pipe->screen); 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(); + dst = trace_surface_unwrap(tr_ctx, dst); - trace_screen_remove_from_list(tr_scr, contexts, tr_ctx); + trace_dump_call_begin("pipe_context", "clear_depth_stencil"); - pipe->destroy(pipe); + 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); - FREE(tr_ctx); + pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil, + dstx, dsty, width, height); + + trace_dump_call_end(); } -static unsigned int -trace_is_texture_referenced( struct pipe_context *_pipe, - struct pipe_texture *_texture, - unsigned face, unsigned level) +static INLINE void +trace_context_flush(struct pipe_context *_pipe, + struct pipe_fence_handle **fence, + enum pipe_flush_flags flags) { 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_call_begin("pipe_context", "flush"); + trace_dump_arg(ptr, pipe); - trace_dump_arg(ptr, texture); - trace_dump_arg(uint, face); - trace_dump_arg(uint, level); + trace_dump_arg(uint, flags); - referenced = pipe->is_texture_referenced(pipe, texture, face, level); + pipe->flush(pipe, fence, flags); - trace_dump_ret(uint, referenced); - trace_dump_call_end(); + if(fence) + trace_dump_ret(ptr, *fence); - return referenced; + trace_dump_call_end(); } -static unsigned int -trace_is_buffer_referenced( struct pipe_context *_pipe, - struct pipe_buffer *_buf) + +static INLINE void +trace_context_destroy(struct pipe_context *_pipe) { 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_call_begin("pipe_context", "destroy"); 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; + pipe->destroy(pipe); + + FREE(tr_ctx); } @@ -1348,134 +1327,189 @@ trace_is_buffer_referenced( struct pipe_context *_pipe, */ -static struct pipe_transfer * -trace_context_get_tex_transfer(struct pipe_context *_context, - struct pipe_texture *_texture, - unsigned face, unsigned level, - unsigned zslice, - enum pipe_transfer_usage usage, - unsigned x, unsigned y, unsigned w, unsigned h) +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_texture *tr_tex = trace_texture(_texture); + struct trace_resource *tr_res = trace_resource(_resource); struct pipe_context *context = tr_context->pipe; - struct pipe_texture *texture = tr_tex->texture; + struct pipe_resource *texture = tr_res->resource; struct pipe_transfer *result = NULL; + void *map; assert(texture->screen == context->screen); - trace_dump_call_begin("pipe_context", "get_tex_transfer"); + /* + * Map and transfers can't be serialized so we convert all write transfers + * to transfer_inline_write and ignore read transfers. + */ - trace_dump_arg(ptr, context); - 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); - - trace_dump_arg(uint, x); - trace_dump_arg(uint, y); - trace_dump_arg(uint, w); - trace_dump_arg(uint, h); + map = context->transfer_map(context, texture, level, usage, box, &result); + if (!map) + return NULL; - result = context->get_tex_transfer(context, texture, face, level, zslice, usage, - x, y, w, h); + *transfer = trace_transfer_create(tr_context, tr_res, result); - trace_dump_ret(ptr, result); + if (map) { + if(usage & PIPE_TRANSFER_WRITE) { + trace_transfer(*transfer)->map = map; + } + } - trace_dump_call_end(); + return *transfer ? map : NULL; +} - if (result) - result = trace_transfer_create(tr_context, tr_tex, result); +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; - return result; + context->transfer_flush_region(context, + transfer, + box); } - static void -trace_context_tex_transfer_destroy(struct pipe_context *_context, - struct pipe_transfer *_transfer) +trace_context_transfer_unmap(struct pipe_context *_context, + struct pipe_transfer *_transfer) { - struct trace_context *tr_context = trace_context(_context); + struct trace_context *tr_ctx = trace_context(_context); struct trace_transfer *tr_trans = trace_transfer(_transfer); - struct pipe_context *context = tr_context->pipe; + struct pipe_context *context = tr_ctx->pipe; struct pipe_transfer *transfer = tr_trans->transfer; - trace_dump_call_begin("pipe_context", "tex_transfer_destroy"); + if(tr_trans->map) { + /* + * Fake a transfer_inline_write + */ - trace_dump_arg(ptr, context); - trace_dump_arg(ptr, transfer); + 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_end(); + 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->format, + 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; + } - trace_transfer_destroy(tr_context, tr_trans); + context->transfer_unmap(context, transfer); + trace_transfer_destroy(tr_ctx, tr_trans); } -static void * -trace_context_transfer_map(struct pipe_context *_context, - struct pipe_transfer *_transfer) +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_transfer *tr_trans = trace_transfer(_transfer); + struct trace_resource *tr_res = trace_resource(_resource); struct pipe_context *context = tr_context->pipe; - struct pipe_transfer *transfer = tr_trans->transfer; - void *map; + struct pipe_resource *resource = tr_res->resource; - map = context->transfer_map(context, transfer); - if(map) { - if(transfer->usage & PIPE_TRANSFER_WRITE) { - assert(!tr_trans->map); - tr_trans->map = map; - } - } + 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->format, + box, + stride, + layer_stride); + trace_dump_arg_end(); - return map; + 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_transfer_unmap(struct pipe_context *_context, - struct pipe_transfer *_transfer) +static void trace_context_render_condition(struct pipe_context *_context, + struct pipe_query *query, + uint mode) { - 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; + struct trace_context *tr_context = trace_context(_context); + struct pipe_context *context = tr_context->pipe; - if(tr_trans->map) { - size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride; + trace_dump_call_begin("pipe_context", "render_condition"); - trace_dump_call_begin("pipe_context", "transfer_write"); + trace_dump_arg(ptr, context); + trace_dump_arg(ptr, query); + trace_dump_arg(uint, mode); - trace_dump_arg(ptr, context); + trace_dump_call_end(); - trace_dump_arg(ptr, transfer); + context->render_condition(context, query, mode); +} - trace_dump_arg_begin("stride"); - trace_dump_uint(transfer->stride); - trace_dump_arg_end(); - trace_dump_arg_begin("data"); - trace_dump_bytes(tr_trans->map, size); - trace_dump_arg_end(); +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_arg_begin("size"); - trace_dump_uint(size); - trace_dump_arg_end(); + trace_dump_call_begin("pipe_context", "texture_barrier"); - trace_dump_call_end(); + trace_dump_arg(ptr, context); - tr_trans->map = NULL; - } + trace_dump_call_end(); - context->transfer_unmap(context, transfer); + context->texture_barrier(context); } + static const struct debug_named_value rbug_blocker_flags[] = { - {"before", 1}, - {"after", 2}, - {NULL, 0}, + {"before", 1, NULL}, + {"after", 2, NULL}, + DEBUG_NAMED_VALUE_END }; struct pipe_context * @@ -1494,81 +1528,100 @@ trace_context_create(struct trace_screen *tr_scr, if(!tr_ctx) goto error1; - tr_ctx->base.winsys = NULL; tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */ tr_ctx->base.screen = &tr_scr->base; - 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.destroy = trace_context_destroy; - 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_fragment_sampler_states = trace_context_bind_fragment_sampler_states; - tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_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.create_vertex_elements_state = trace_context_create_vertex_elements_state; - tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state; - tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state; - tr_ctx->base.set_blend_color = trace_context_set_blend_color; - tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref; - 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_fragment_sampler_views = trace_context_set_fragment_sampler_views; - tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views; - tr_ctx->base.create_sampler_view = trace_create_sampler_view; - tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy; - tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers; - 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->base.get_tex_transfer = trace_context_get_tex_transfer; - tr_ctx->base.tex_transfer_destroy = trace_context_tex_transfer_destroy; - tr_ctx->base.transfer_map = trace_context_transfer_map; - tr_ctx->base.transfer_unmap = trace_context_transfer_unmap; - tr_ctx->pipe = pipe; +#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_state); + TR_CTX_INIT(set_viewport_state); + 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 - trace_screen_add_to_list(tr_scr, contexts, tr_ctx); + 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); +} +