/**************************************************************************
*
- * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2008 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#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_defines.h"
#include "tr_dump_state.h"
-#include "tr_state.h"
+#include "tr_public.h"
#include "tr_screen.h"
#include "tr_texture.h"
+#include "tr_context.h"
+struct trace_query
+{
+ unsigned type;
+
+ struct pipe_query *query;
+};
+
+static INLINE struct trace_query *
+trace_query(struct pipe_query *query) {
+ return (struct trace_query *)query;
+}
+
+
+static INLINE struct pipe_query *
+trace_query_unwrap(struct pipe_query *query)
+{
+ if (query) {
+ return trace_query(query)->query;
+ } else {
+ return NULL;
+ }
+}
static INLINE struct pipe_resource *
trace_resource_unwrap(struct trace_context *tr_ctx,
struct pipe_resource *resource)
{
- struct trace_resource *tr_tex;
+ struct trace_resource *tr_res;
if(!resource)
return NULL;
- tr_tex = trace_resource(resource);
+ tr_res = trace_resource(resource);
- assert(tr_tex->resource);
- return tr_tex->resource;
+ assert(tr_res->resource);
+ return tr_res->resource;
}
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)
+trace_context_draw_vbo(struct pipe_context *_pipe,
+ const struct pipe_draw_info *info)
{
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_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_dump_call_begin("pipe_context", "draw_arrays");
+ trace_dump_trace_flush();
- 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);
+ pipe->draw_vbo(pipe, info);
trace_dump_call_end();
-
- trace_context_draw_block(tr_ctx, 2);
-}
-
-
-static INLINE void
-trace_context_draw_elements(struct pipe_context *_pipe,
- struct pipe_resource *_indexBuffer,
- unsigned indexSize, int indexBias,
- unsigned mode, unsigned start, unsigned count)
-{
- struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_resource *tr_buf = trace_resource(_indexBuffer);
- struct pipe_context *pipe = tr_ctx->pipe;
- struct pipe_resource *indexBuffer = tr_buf->resource;
-
- 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_elements");
-
- trace_dump_arg(ptr, pipe);
- trace_dump_arg(ptr, indexBuffer);
- trace_dump_arg(uint, indexSize);
- trace_dump_arg(int, indexBias);
- trace_dump_arg(uint, mode);
- trace_dump_arg(uint, start);
- trace_dump_arg(uint, count);
-
- pipe->draw_elements(pipe, indexBuffer, indexSize, indexBias,
- 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_resource *_indexBuffer,
- unsigned indexSize,
- int indexBias,
- unsigned minIndex,
- unsigned maxIndex,
- unsigned mode,
- unsigned start,
- unsigned count)
-{
- struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_resource *tr_buf = trace_resource(_indexBuffer);
- struct pipe_context *pipe = tr_ctx->pipe;
- struct pipe_resource *indexBuffer = tr_buf->resource;
-
- 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_range_elements");
-
- trace_dump_arg(ptr, pipe);
- trace_dump_arg(ptr, indexBuffer);
- trace_dump_arg(uint, indexSize);
- trace_dump_arg(int, indexBias);
- 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, indexBias,
- minIndex, maxIndex,
- mode, start, count);
-
- trace_dump_call_end();
-
- trace_context_draw_block(tr_ctx, 2);
}
static INLINE struct pipe_query *
trace_context_create_query(struct pipe_context *_pipe,
- unsigned query_type)
+ unsigned query_type,
+ unsigned index)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
- struct pipe_query *result;
+ struct pipe_query *query;
trace_dump_call_begin("pipe_context", "create_query");
trace_dump_arg(ptr, pipe);
- trace_dump_arg(uint, query_type);
+ trace_dump_arg(query_type, query_type);
+ trace_dump_arg(int, index);
- result = pipe->create_query(pipe, query_type);
+ query = pipe->create_query(pipe, query_type, index);
- trace_dump_ret(ptr, result);
+ trace_dump_ret(ptr, query);
trace_dump_call_end();
- return result;
+ /* Wrap query object. */
+ if (query) {
+ struct trace_query *tr_query = CALLOC_STRUCT(trace_query);
+ if (tr_query) {
+ tr_query->type = query_type;
+ tr_query->query = query;
+ query = (struct pipe_query *)tr_query;
+ } else {
+ pipe->destroy_query(pipe, query);
+ query = NULL;
+ }
+ }
+
+ return query;
}
static INLINE void
trace_context_destroy_query(struct pipe_context *_pipe,
- struct pipe_query *query)
+ struct pipe_query *_query)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
+ struct trace_query *tr_query = trace_query(_query);
+ struct pipe_query *query = tr_query->query;
+
+ FREE(tr_query);
trace_dump_call_begin("pipe_context", "destroy_query");
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
+ query = trace_query_unwrap(query);
+
trace_dump_call_begin("pipe_context", "begin_query");
trace_dump_arg(ptr, pipe);
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
+ query = trace_query_unwrap(query);
+
trace_dump_call_begin("pipe_context", "end_query");
trace_dump_arg(ptr, pipe);
static INLINE boolean
trace_context_get_query_result(struct pipe_context *_pipe,
- struct pipe_query *query,
+ struct pipe_query *_query,
boolean wait,
- uint64_t *presult)
+ union pipe_query_result *result)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
- uint64_t result;
- boolean _result;
+ struct trace_query *tr_query = trace_query(_query);
+ struct pipe_query *query = tr_query->query;
+ boolean ret;
trace_dump_call_begin("pipe_context", "get_query_result");
trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, query);
+
+ ret = pipe->get_query_result(pipe, query, wait, result);
- _result = pipe->get_query_result(pipe, query, wait, presult);
- result = *presult;
+ trace_dump_arg_begin("result");
+ if (ret) {
+ trace_dump_query_result(tr_query->type, result);
+ } else {
+ trace_dump_null();
+ }
+ trace_dump_arg_end();
- trace_dump_arg(uint, result);
- trace_dump_ret(bool, _result);
+ trace_dump_ret(bool, ret);
trace_dump_call_end();
- return _result;
+ return ret;
}
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");
-
- 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);
-
- trace_dump_call_end();
-}
-
-
-static INLINE void
-trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
- unsigned num_states,
- void **states)
-{
- struct trace_context *tr_ctx = trace_context(_pipe);
- struct pipe_context *pipe = tr_ctx->pipe;
+ /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
+ assert(start == 0);
- trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
+ trace_dump_call_begin("pipe_context", "bind_sampler_states");
trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, shader);
+ trace_dump_arg(uint, start);
trace_dump_arg(uint, num_states);
trace_dump_arg_array(ptr, states, num_states);
- pipe->bind_vertex_sampler_states(pipe, num_states, states);
+ pipe->bind_sampler_states(pipe, shader, start, num_states, states);
trace_dump_call_end();
}
}
-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 *
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);
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_resource *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) {
- buffer = trace_resource_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");
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();
}
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_resource(state->cbufs[i]->texture);
- else
- tr_ctx->curr.cbufs[i] = NULL;
- if (state->zsbuf)
- tr_ctx->curr.zsbuf = trace_resource(state->zsbuf->texture);
- else
- tr_ctx->curr.zsbuf = NULL;
- }
/* Unwrap the input state */
memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
static INLINE void
-trace_context_set_scissor_state(struct pipe_context *_pipe,
- const struct pipe_scissor_state *state)
+trace_context_set_scissor_states(struct pipe_context *_pipe,
+ unsigned start_slot,
+ unsigned num_scissors,
+ const struct pipe_scissor_state *states)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin("pipe_context", "set_scissor_state");
+ trace_dump_call_begin("pipe_context", "set_scissor_states");
trace_dump_arg(ptr, pipe);
- trace_dump_arg(scissor_state, state);
+ trace_dump_arg(uint, start_slot);
+ trace_dump_arg(uint, num_scissors);
+ trace_dump_arg(scissor_state, states);
- pipe->set_scissor_state(pipe, state);
+ pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
trace_dump_call_end();
}
static INLINE void
-trace_context_set_viewport_state(struct pipe_context *_pipe,
- const struct pipe_viewport_state *state)
+trace_context_set_viewport_states(struct pipe_context *_pipe,
+ unsigned start_slot,
+ unsigned num_viewports,
+ const struct pipe_viewport_state *states)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin("pipe_context", "set_viewport_state");
+ trace_dump_call_begin("pipe_context", "set_viewport_states");
trace_dump_arg(ptr, pipe);
- trace_dump_arg(viewport_state, state);
+ trace_dump_arg(uint, start_slot);
+ trace_dump_arg(uint, num_viewports);
+ trace_dump_arg(viewport_state, states);
- pipe->set_viewport_state(pipe, state);
+ pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
trace_dump_call_end();
}
static struct pipe_sampler_view *
-trace_create_sampler_view(struct pipe_context *_pipe,
+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_resource *tr_tex = trace_resource(_resource);
+ struct trace_resource *tr_res = trace_resource(_resource);
struct pipe_context *pipe = tr_ctx->pipe;
- struct pipe_resource *texture = tr_tex->resource;
+ 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(sampler_view_template, templ);
+ trace_dump_arg(ptr, resource);
- result = 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 = pipe->create_sampler_view(pipe, resource, templ);
trace_dump_ret(ptr, 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);
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();
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;
-
- 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;
+ struct pipe_resource *resource = tr_res->resource;
+ struct pipe_surface *result = NULL;
- 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_SHADER_SAMPLER_VIEWS];
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");
+ trace_dump_call_begin("pipe_context", "set_sampler_views");
trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, shader);
+ trace_dump_arg(uint, start);
trace_dump_arg(uint, num);
trace_dump_arg_array(ptr, views, num);
- pipe->set_vertex_sampler_views(pipe, num, views);
+ pipe->set_sampler_views(pipe, shader, start, num, views);
trace_dump_call_end();
}
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);
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) {
+ 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_resource_unwrap(tr_ctx, buffers[i].buffer);
- pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
+ 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();
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);
+
+ result = pipe->create_stream_output_target(pipe,
+ res, buffer_offset, buffer_size);
- pipe->surface_copy(pipe,
- dest, destx, desty,
- src, srcx, srcy, width, height);
+ trace_dump_ret(ptr, result);
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);
+
+ 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,
+ const unsigned *offsets)
+{
+ struct trace_context *tr_ctx = trace_context(_pipe);
+ struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin("pipe_context", "surface_fill");
+ 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_array(uint, offsets, num_targets);
+
+ pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
+
+ 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->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->surface_fill(pipe, dst, dstx, dsty, width, height, value);
+ pipe->blit(pipe, &info);
+
+ trace_dump_call_end();
+}
+
+
+static void
+trace_context_flush_resource(struct pipe_context *_pipe,
+ struct pipe_resource *resource)
+{
+ struct trace_context *tr_ctx = trace_context(_pipe);
+ struct pipe_context *pipe = tr_ctx->pipe;
+
+ resource = trace_resource_unwrap(tr_ctx, resource);
+
+ trace_dump_call_begin("pipe_context", "flush_resource");
+
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, resource);
+
+ pipe->flush_resource(pipe, resource);
trace_dump_call_end();
}
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)
{
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_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;
+
+ dst = trace_surface_unwrap(tr_ctx, dst);
+
+ trace_dump_call_begin("pipe_context", "clear_render_target");
+
+ trace_dump_arg(ptr, pipe);
+ 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->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
+
+ trace_dump_call_end();
+}
+
+static INLINE void
+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_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", "clear_depth_stencil");
+
+ 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);
+
+ pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
+ dstx, dsty, width, height);
+
+ trace_dump_call_end();
+}
+
static INLINE void
trace_context_flush(struct pipe_context *_pipe,
- unsigned flags,
- struct pipe_fence_handle **fence)
+ struct pipe_fence_handle **fence,
+ unsigned flags)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
trace_dump_arg(ptr, pipe);
trace_dump_arg(uint, flags);
- pipe->flush(pipe, flags, fence);
+ pipe->flush(pipe, fence, flags);
if(fence)
trace_dump_ret(ptr, *fence);
static INLINE void
trace_context_destroy(struct pipe_context *_pipe)
{
- 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_arg(ptr, pipe);
trace_dump_call_end();
- trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
-
pipe->destroy(pipe);
FREE(tr_ctx);
}
-static unsigned int
-trace_is_resource_referenced( struct pipe_context *_pipe,
- struct pipe_resource *_resource,
- unsigned face, unsigned level)
-{
- struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_resource *tr_tex = trace_resource(_resource);
- struct pipe_context *pipe = tr_ctx->pipe;
- struct pipe_resource *texture = tr_tex->resource;
- unsigned int referenced;
-
- trace_dump_call_begin("pipe_context", "is_resource_referenced");
- trace_dump_arg(ptr, pipe);
- trace_dump_arg(ptr, texture);
- trace_dump_arg(uint, face);
- trace_dump_arg(uint, level);
-
- referenced = pipe->is_resource_referenced(pipe, texture, face, level);
-
- trace_dump_ret(uint, referenced);
- trace_dump_call_end();
-
- return referenced;
-}
-
/********************************************************************
* transfer
*/
-static struct pipe_transfer *
-trace_context_get_transfer(struct pipe_context *_context,
- struct pipe_resource *_resource,
- struct pipe_subresource sr,
- unsigned usage,
- const struct pipe_box *box)
+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_resource *tr_tex = trace_resource(_resource);
+ struct trace_resource *tr_res = trace_resource(_resource);
struct pipe_context *context = tr_context->pipe;
- struct pipe_resource *texture = tr_tex->resource;
+ struct pipe_resource *texture = tr_res->resource;
struct pipe_transfer *result = NULL;
+ void *map;
assert(texture->screen == context->screen);
* to transfer_inline_write and ignore read transfers.
*/
- result = context->get_transfer(context, texture, sr, usage, box);
-
- if (result)
- result = trace_transfer_create(tr_context, tr_tex, result);
-
- return result;
-}
-
-
-static void
-trace_context_transfer_destroy(struct pipe_context *_context,
- struct pipe_transfer *_transfer)
-{
- struct trace_context *tr_context = trace_context(_context);
- struct trace_transfer *tr_trans = trace_transfer(_transfer);
-
- trace_transfer_destroy(tr_context, tr_trans);
-}
-
+ map = context->transfer_map(context, texture, level, usage, box, &result);
+ if (!map)
+ return NULL;
-static void *
-trace_context_transfer_map(struct pipe_context *_context,
- struct pipe_transfer *_transfer)
-{
- struct trace_context *tr_context = trace_context(_context);
- struct trace_transfer *tr_trans = trace_transfer(_transfer);
- struct pipe_context *context = tr_context->pipe;
- struct pipe_transfer *transfer = tr_trans->transfer;
- void *map;
+ *transfer = trace_transfer_create(tr_context, tr_res, result);
- map = context->transfer_map(context, transfer);
- if(map) {
- if(transfer->usage & PIPE_TRANSFER_WRITE) {
- assert(!tr_trans->map);
- tr_trans->map = map;
+ if (map) {
+ if(usage & PIPE_TRANSFER_WRITE) {
+ trace_transfer(*transfer)->map = map;
}
}
- return map;
+ return *transfer ? map : NULL;
}
-
static void
trace_context_transfer_flush_region( struct pipe_context *_context,
struct pipe_transfer *_transfer,
static void
trace_context_transfer_unmap(struct pipe_context *_context,
- struct pipe_transfer *_transfer)
+ struct pipe_transfer *_transfer)
{
struct trace_context *tr_ctx = trace_context(_context);
struct trace_transfer *tr_trans = trace_transfer(_transfer);
*/
struct pipe_resource *resource = transfer->resource;
- struct pipe_subresource sr = transfer->sr;
+ unsigned level = transfer->level;
unsigned usage = transfer->usage;
const struct pipe_box *box = &transfer->box;
unsigned stride = transfer->stride;
- unsigned slice_stride = transfer->slice_stride;
+ unsigned layer_stride = transfer->layer_stride;
trace_dump_call_begin("pipe_context", "transfer_inline_write");
trace_dump_arg(ptr, context);
trace_dump_arg(ptr, resource);
- trace_dump_arg_struct(subresource, sr);
+ 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,
+ resource,
box,
stride,
- slice_stride);
+ layer_stride);
trace_dump_arg_end();
trace_dump_arg(uint, stride);
- trace_dump_arg(uint, slice_stride);
+ trace_dump_arg(uint, layer_stride);
trace_dump_call_end();
}
context->transfer_unmap(context, transfer);
+ trace_transfer_destroy(tr_ctx, tr_trans);
}
static void
trace_context_transfer_inline_write(struct pipe_context *_context,
- struct pipe_resource *_resource,
- struct pipe_subresource sr,
- unsigned usage,
- const struct pipe_box *box,
- const void *data,
- unsigned stride,
- unsigned slice_stride)
+ 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_resource *tr_tex = trace_resource(_resource);
+ struct trace_resource *tr_res = trace_resource(_resource);
struct pipe_context *context = tr_context->pipe;
- struct pipe_resource *resource = tr_tex->resource;
+ struct pipe_resource *resource = tr_res->resource;
assert(resource->screen == context->screen);
trace_dump_arg(ptr, context);
trace_dump_arg(ptr, resource);
- trace_dump_arg_struct(subresource, sr);
+ 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,
+ resource,
box,
stride,
- slice_stride);
+ layer_stride);
trace_dump_arg_end();
trace_dump_arg(uint, stride);
- trace_dump_arg(uint, slice_stride);
+ trace_dump_arg(uint, layer_stride);
trace_dump_call_end();
context->transfer_inline_write(context, resource,
- sr, usage, box, data, stride, slice_stride);
+ level, usage, box, data, stride, layer_stride);
+}
+
+
+static void trace_context_render_condition(struct pipe_context *_context,
+ struct pipe_query *query,
+ boolean condition,
+ uint mode)
+{
+ struct trace_context *tr_context = trace_context(_context);
+ struct pipe_context *context = tr_context->pipe;
+
+ query = trace_query_unwrap(query);
+
+ trace_dump_call_begin("pipe_context", "render_condition");
+
+ trace_dump_arg(ptr, context);
+ trace_dump_arg(ptr, query);
+ trace_dump_arg(bool, condition);
+ trace_dump_arg(uint, mode);
+
+ trace_dump_call_end();
+
+ context->render_condition(context, query, condition, mode);
+}
+
+
+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_call_begin("pipe_context", "texture_barrier");
+
+ trace_dump_arg(ptr, context);
+
+ trace_dump_call_end();
+
+ context->texture_barrier(context);
}
+static void trace_context_memory_barrier(struct pipe_context *_context,
+ unsigned flags)
+{
+ struct trace_context *tr_context = trace_context(_context);
+ struct pipe_context *context = tr_context->pipe;
+
+ trace_dump_call_begin("pipe_context", "memory_barrier");
+ trace_dump_arg(ptr, context);
+ trace_dump_arg(uint, flags);
+ trace_dump_call_end();
+
+ context->memory_barrier(context, flags);
+}
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 *
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_resource_referenced = trace_is_resource_referenced;
-
- tr_ctx->base.get_transfer = trace_context_get_transfer;
- tr_ctx->base.transfer_destroy = trace_context_transfer_destroy;
- tr_ctx->base.transfer_map = trace_context_transfer_map;
- tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
- tr_ctx->base.transfer_flush_region = trace_context_transfer_flush_region;
- tr_ctx->base.transfer_inline_write = trace_context_transfer_inline_write;
- 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_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_states);
+ TR_CTX_INIT(set_viewport_states);
+ TR_CTX_INIT(set_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(flush_resource);
+ 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(memory_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);
+}
+
projects / mesa.git / blobdiff