2190 lines
63 KiB
C
2190 lines
63 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright 2008 VMware, Inc.
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* 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 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/ralloc.h"
|
|
#include "util/u_inlines.h"
|
|
#include "util/u_memory.h"
|
|
#include "util/simple_list.h"
|
|
#include "util/u_framebuffer.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_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_surface *
|
|
trace_surface_unwrap(struct trace_context *tr_ctx,
|
|
struct pipe_surface *surface)
|
|
{
|
|
struct trace_surface *tr_surf;
|
|
|
|
if (!surface)
|
|
return NULL;
|
|
|
|
assert(surface->texture);
|
|
if (!surface->texture)
|
|
return surface;
|
|
|
|
tr_surf = trace_surface(surface);
|
|
|
|
assert(tr_surf->surface);
|
|
return tr_surf->surface;
|
|
}
|
|
|
|
static void
|
|
dump_fb_state(struct trace_context *tr_ctx,
|
|
const char *method,
|
|
bool deep)
|
|
{
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", method);
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
if (deep)
|
|
trace_dump_arg(framebuffer_state_deep, &tr_ctx->unwrapped_state);
|
|
else
|
|
trace_dump_arg(framebuffer_state, &tr_ctx->unwrapped_state);
|
|
trace_dump_call_end();
|
|
|
|
tr_ctx->seen_fb_state = true;
|
|
}
|
|
|
|
static void
|
|
trace_context_draw_vbo(struct pipe_context *_pipe,
|
|
const struct pipe_draw_info *info,
|
|
const struct pipe_draw_indirect_info *indirect,
|
|
const struct pipe_draw_start_count *draws,
|
|
unsigned num_draws)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
if (!tr_ctx->seen_fb_state && trace_dump_is_triggered())
|
|
dump_fb_state(tr_ctx, "current_framebuffer_state", true);
|
|
|
|
trace_dump_call_begin("pipe_context", "draw_vbo");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(draw_info, info);
|
|
trace_dump_arg(draw_indirect_info, indirect);
|
|
trace_dump_arg_begin("draws");
|
|
trace_dump_struct_array(draw_start_count, draws, num_draws);
|
|
trace_dump_arg_end();
|
|
trace_dump_arg(uint, num_draws);
|
|
|
|
trace_dump_trace_flush();
|
|
|
|
pipe->draw_vbo(pipe, info, indirect, draws, num_draws);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static struct pipe_query *
|
|
trace_context_create_query(struct pipe_context *_pipe,
|
|
unsigned query_type,
|
|
unsigned index)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
struct pipe_query *query;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_query");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(query_type, query_type);
|
|
trace_dump_arg(int, index);
|
|
|
|
query = pipe->create_query(pipe, query_type, index);
|
|
|
|
trace_dump_ret(ptr, query);
|
|
|
|
trace_dump_call_end();
|
|
|
|
/* 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 void
|
|
trace_context_destroy_query(struct pipe_context *_pipe,
|
|
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");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, query);
|
|
|
|
pipe->destroy_query(pipe, query);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static bool
|
|
trace_context_begin_query(struct pipe_context *_pipe,
|
|
struct pipe_query *query)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
bool ret;
|
|
|
|
query = trace_query_unwrap(query);
|
|
|
|
trace_dump_call_begin("pipe_context", "begin_query");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, query);
|
|
|
|
ret = pipe->begin_query(pipe, query);
|
|
|
|
trace_dump_call_end();
|
|
return ret;
|
|
}
|
|
|
|
|
|
static bool
|
|
trace_context_end_query(struct pipe_context *_pipe,
|
|
struct pipe_query *query)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
bool ret;
|
|
|
|
query = trace_query_unwrap(query);
|
|
|
|
trace_dump_call_begin("pipe_context", "end_query");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, query);
|
|
|
|
ret = pipe->end_query(pipe, query);
|
|
|
|
trace_dump_call_end();
|
|
return ret;
|
|
}
|
|
|
|
|
|
static bool
|
|
trace_context_get_query_result(struct pipe_context *_pipe,
|
|
struct pipe_query *_query,
|
|
bool wait,
|
|
union pipe_query_result *result)
|
|
{
|
|
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;
|
|
bool 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);
|
|
|
|
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_ret(bool, ret);
|
|
|
|
trace_dump_call_end();
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_active_query_state(struct pipe_context *_pipe,
|
|
bool enable)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_active_query_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(bool, enable);
|
|
|
|
pipe->set_active_query_state(pipe, enable);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void *
|
|
trace_context_create_blend_state(struct pipe_context *_pipe,
|
|
const struct pipe_blend_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_blend_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(blend_state, state);
|
|
|
|
result = pipe->create_blend_state(pipe, state);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
struct pipe_blend_state *blend = ralloc(tr_ctx, struct pipe_blend_state);
|
|
if (blend) {
|
|
memcpy(blend, state, sizeof(struct pipe_blend_state));
|
|
_mesa_hash_table_insert(&tr_ctx->blend_states, result, blend);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_bind_blend_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_blend_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
if (state && trace_dump_is_triggered()) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->blend_states, state);
|
|
if (he)
|
|
trace_dump_arg(blend_state, he->data);
|
|
else
|
|
trace_dump_arg(blend_state, NULL);
|
|
} else
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->bind_blend_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_delete_blend_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_blend_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->delete_blend_state(pipe, state);
|
|
|
|
if (state) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->blend_states, state);
|
|
if (he) {
|
|
ralloc_free(he->data);
|
|
_mesa_hash_table_remove(&tr_ctx->blend_states, he);
|
|
}
|
|
}
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void *
|
|
trace_context_create_sampler_state(struct pipe_context *_pipe,
|
|
const struct pipe_sampler_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_sampler_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(sampler_state, state);
|
|
|
|
result = pipe->create_sampler_state(pipe, state);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_bind_sampler_states(struct pipe_context *_pipe,
|
|
enum pipe_shader_type shader,
|
|
unsigned start,
|
|
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_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_sampler_states(pipe, shader, start, num_states, states);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_delete_sampler_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_sampler_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->delete_sampler_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void *
|
|
trace_context_create_rasterizer_state(struct pipe_context *_pipe,
|
|
const struct pipe_rasterizer_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_rasterizer_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(rasterizer_state, state);
|
|
|
|
result = pipe->create_rasterizer_state(pipe, state);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
struct pipe_rasterizer_state *rasterizer = ralloc(tr_ctx, struct pipe_rasterizer_state);
|
|
if (rasterizer) {
|
|
memcpy(rasterizer, state, sizeof(struct pipe_rasterizer_state));
|
|
_mesa_hash_table_insert(&tr_ctx->rasterizer_states, result, rasterizer);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_bind_rasterizer_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_rasterizer_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
if (state && trace_dump_is_triggered()) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->rasterizer_states, state);
|
|
if (he)
|
|
trace_dump_arg(rasterizer_state, he->data);
|
|
else
|
|
trace_dump_arg(rasterizer_state, NULL);
|
|
} else
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->bind_rasterizer_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_delete_rasterizer_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_rasterizer_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->delete_rasterizer_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
|
|
if (state) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->rasterizer_states, state);
|
|
if (he) {
|
|
ralloc_free(he->data);
|
|
_mesa_hash_table_remove(&tr_ctx->rasterizer_states, he);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static void *
|
|
trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
|
|
const struct pipe_depth_stencil_alpha_state *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
void * result;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
|
|
|
|
result = pipe->create_depth_stencil_alpha_state(pipe, state);
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(depth_stencil_alpha_state, state);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
struct pipe_depth_stencil_alpha_state *depth_stencil_alpha = ralloc(tr_ctx, struct pipe_depth_stencil_alpha_state);
|
|
if (depth_stencil_alpha) {
|
|
memcpy(depth_stencil_alpha, state, sizeof(struct pipe_depth_stencil_alpha_state));
|
|
_mesa_hash_table_insert(&tr_ctx->depth_stencil_alpha_states, result, depth_stencil_alpha);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_bind_depth_stencil_alpha_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_depth_stencil_alpha_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
if (state && trace_dump_is_triggered()) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->depth_stencil_alpha_states, state);
|
|
if (he)
|
|
trace_dump_arg(depth_stencil_alpha_state, he->data);
|
|
else
|
|
trace_dump_arg(depth_stencil_alpha_state, NULL);
|
|
} else
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->bind_depth_stencil_alpha_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_delete_depth_stencil_alpha_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_depth_stencil_alpha_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->delete_depth_stencil_alpha_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
|
|
if (state) {
|
|
struct hash_entry *he = _mesa_hash_table_search(&tr_ctx->depth_stencil_alpha_states, state);
|
|
if (he) {
|
|
ralloc_free(he->data);
|
|
_mesa_hash_table_remove(&tr_ctx->depth_stencil_alpha_states, he);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#define TRACE_SHADER_STATE(shader_type) \
|
|
static 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 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 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_SHADER_STATE(fs)
|
|
TRACE_SHADER_STATE(vs)
|
|
TRACE_SHADER_STATE(gs)
|
|
TRACE_SHADER_STATE(tcs)
|
|
TRACE_SHADER_STATE(tes)
|
|
|
|
#undef TRACE_SHADER_STATE
|
|
|
|
|
|
static inline void *
|
|
trace_context_create_compute_state(struct pipe_context *_pipe,
|
|
const struct pipe_compute_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_compute_state");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(compute_state, state);
|
|
result = pipe->create_compute_state(pipe, state);
|
|
trace_dump_ret(ptr, result);
|
|
trace_dump_call_end();
|
|
return result;
|
|
}
|
|
|
|
static inline void
|
|
trace_context_bind_compute_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_compute_state");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
pipe->bind_compute_state(pipe, state);
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static inline void
|
|
trace_context_delete_compute_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_compute_state");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
pipe->delete_compute_state(pipe, state);
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static void *
|
|
trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
|
|
unsigned num_elements,
|
|
const struct pipe_vertex_element *elements)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
void * result;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, num_elements);
|
|
|
|
trace_dump_arg_begin("elements");
|
|
trace_dump_struct_array(vertex_element, elements, num_elements);
|
|
trace_dump_arg_end();
|
|
|
|
result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_bind_vertex_elements_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_vertex_elements_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->bind_vertex_elements_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_delete_vertex_elements_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_vertex_elements_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, state);
|
|
|
|
pipe->delete_vertex_elements_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_blend_color(struct pipe_context *_pipe,
|
|
const struct pipe_blend_color *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_blend_color");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(blend_color, state);
|
|
|
|
pipe->set_blend_color(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_stencil_ref(struct pipe_context *_pipe,
|
|
const struct pipe_stencil_ref state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_stencil_ref");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(stencil_ref, &state);
|
|
|
|
pipe->set_stencil_ref(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_clip_state(struct pipe_context *_pipe,
|
|
const struct pipe_clip_state *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_clip_state");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(clip_state, state);
|
|
|
|
pipe->set_clip_state(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static 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 void
|
|
trace_context_set_constant_buffer(struct pipe_context *_pipe,
|
|
enum pipe_shader_type shader, uint index,
|
|
bool take_ownership,
|
|
const struct pipe_constant_buffer *constant_buffer)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
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(bool, take_ownership);
|
|
trace_dump_arg(constant_buffer, constant_buffer);
|
|
|
|
pipe->set_constant_buffer(pipe, shader, index, take_ownership, constant_buffer);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_framebuffer_state(struct pipe_context *_pipe,
|
|
const struct pipe_framebuffer_state *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
unsigned i;
|
|
|
|
/* Unwrap the input state */
|
|
memcpy(&tr_ctx->unwrapped_state, state, sizeof(tr_ctx->unwrapped_state));
|
|
for (i = 0; i < state->nr_cbufs; ++i)
|
|
tr_ctx->unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
|
|
for (i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
|
|
tr_ctx->unwrapped_state.cbufs[i] = NULL;
|
|
tr_ctx->unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
|
|
state = &tr_ctx->unwrapped_state;
|
|
|
|
dump_fb_state(tr_ctx, "set_framebuffer_state", trace_dump_is_triggered());
|
|
|
|
pipe->set_framebuffer_state(pipe, state);
|
|
}
|
|
|
|
static void
|
|
trace_context_set_inlinable_constants(struct pipe_context *_pipe, enum pipe_shader_type shader,
|
|
uint num_values, uint32_t *values)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_inlinable_constants");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, shader);
|
|
trace_dump_arg(uint, num_values);
|
|
trace_dump_array(uint, values, num_values);
|
|
|
|
pipe->set_inlinable_constants(pipe, shader, num_values, values);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_polygon_stipple(struct pipe_context *_pipe,
|
|
const struct pipe_poly_stipple *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_polygon_stipple");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(poly_stipple, state);
|
|
|
|
pipe->set_polygon_stipple(pipe, state);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static void
|
|
trace_context_set_min_samples(struct pipe_context *_pipe,
|
|
unsigned min_samples)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_min_samples");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, min_samples);
|
|
|
|
pipe->set_min_samples(pipe, min_samples);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
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_states");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, start_slot);
|
|
trace_dump_arg(uint, num_scissors);
|
|
trace_dump_arg(scissor_state, states);
|
|
|
|
pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
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_states");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, start_slot);
|
|
trace_dump_arg(uint, num_viewports);
|
|
trace_dump_arg(viewport_state, states);
|
|
|
|
pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static struct pipe_sampler_view *
|
|
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 pipe_context *pipe = tr_ctx->pipe;
|
|
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, resource);
|
|
|
|
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);
|
|
|
|
trace_dump_call_end();
|
|
|
|
/*
|
|
* 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_context_sampler_view_destroy(struct pipe_context *_pipe,
|
|
struct pipe_sampler_view *_view)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct trace_sampler_view *tr_view = trace_sampler_view(_view);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
struct pipe_sampler_view *view = tr_view->sampler_view;
|
|
|
|
trace_dump_call_begin("pipe_context", "sampler_view_destroy");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, view);
|
|
|
|
pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
|
|
|
|
trace_dump_call_end();
|
|
|
|
pipe_resource_reference(&_view->texture, NULL);
|
|
FREE(_view);
|
|
}
|
|
|
|
/********************************************************************
|
|
* surface
|
|
*/
|
|
|
|
|
|
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 pipe_context *pipe = tr_ctx->pipe;
|
|
struct pipe_surface *result = NULL;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_surface");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, resource);
|
|
|
|
trace_dump_arg_begin("surf_tmpl");
|
|
trace_dump_surface_template(surf_tmpl, resource->target);
|
|
trace_dump_arg_end();
|
|
|
|
|
|
result = pipe->create_surface(pipe, resource, surf_tmpl);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
result = trace_surf_create(tr_ctx, resource, 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 void
|
|
trace_context_set_sampler_views(struct pipe_context *_pipe,
|
|
enum pipe_shader_type shader,
|
|
unsigned start,
|
|
unsigned num,
|
|
unsigned unbind_num_trailing_slots,
|
|
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_SHADER_SAMPLER_VIEWS];
|
|
unsigned i;
|
|
|
|
/* 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]);
|
|
unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
|
|
}
|
|
views = unwrapped_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(uint, unbind_num_trailing_slots);
|
|
trace_dump_arg_array(ptr, views, num);
|
|
|
|
pipe->set_sampler_views(pipe, shader, start, num,
|
|
unbind_num_trailing_slots, views);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_set_vertex_buffers(struct pipe_context *_pipe,
|
|
unsigned start_slot, unsigned num_buffers,
|
|
unsigned unbind_num_trailing_slots,
|
|
bool take_ownership,
|
|
const struct pipe_vertex_buffer *buffers)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->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(uint, unbind_num_trailing_slots);
|
|
trace_dump_arg(bool, take_ownership);
|
|
|
|
trace_dump_arg_begin("buffers");
|
|
trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
|
|
trace_dump_arg_end();
|
|
|
|
pipe->set_vertex_buffers(pipe, start_slot, num_buffers,
|
|
unbind_num_trailing_slots, take_ownership,
|
|
buffers);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static 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;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_stream_output_target");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
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);
|
|
|
|
trace_dump_ret(ptr, result);
|
|
|
|
trace_dump_call_end();
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
static void
|
|
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;
|
|
|
|
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 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", "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 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;
|
|
|
|
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, 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 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;
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
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 void
|
|
trace_context_clear(struct pipe_context *_pipe,
|
|
unsigned buffers,
|
|
const struct pipe_scissor_state *scissor_state,
|
|
const union pipe_color_union *color,
|
|
double depth,
|
|
unsigned stencil)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "clear");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, buffers);
|
|
trace_dump_arg_begin("scissor_state");
|
|
trace_dump_scissor_state(scissor_state);
|
|
trace_dump_arg_end();
|
|
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, scissor_state, color, depth, stencil);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static 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,
|
|
bool render_condition_enabled)
|
|
{
|
|
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);
|
|
trace_dump_arg(bool, render_condition_enabled);
|
|
|
|
pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height,
|
|
render_condition_enabled);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static 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,
|
|
bool render_condition_enabled)
|
|
{
|
|
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);
|
|
trace_dump_arg(bool, render_condition_enabled);
|
|
|
|
pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
|
|
dstx, dsty, width, height,
|
|
render_condition_enabled);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static inline void
|
|
trace_context_clear_texture(struct pipe_context *_pipe,
|
|
struct pipe_resource *res,
|
|
unsigned level,
|
|
const struct pipe_box *box,
|
|
const void *data)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
|
|
trace_dump_call_begin("pipe_context", "clear_texture");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, res);
|
|
trace_dump_arg(uint, level);
|
|
trace_dump_arg_begin("box");
|
|
trace_dump_box(box);
|
|
trace_dump_arg_end();
|
|
trace_dump_arg(ptr, data);
|
|
|
|
pipe->clear_texture(pipe, res, level, box, data);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static void
|
|
trace_context_flush(struct pipe_context *_pipe,
|
|
struct pipe_fence_handle **fence,
|
|
unsigned flags)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "flush");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, flags);
|
|
|
|
pipe->flush(pipe, fence, flags);
|
|
|
|
if (fence)
|
|
trace_dump_ret(ptr, *fence);
|
|
|
|
trace_dump_call_end();
|
|
|
|
if (flags & PIPE_FLUSH_END_OF_FRAME) {
|
|
trace_dump_check_trigger();
|
|
tr_ctx->seen_fb_state = false;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_create_fence_fd(struct pipe_context *_pipe,
|
|
struct pipe_fence_handle **fence,
|
|
int fd,
|
|
enum pipe_fd_type type)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_fence_fd");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(int, fd);
|
|
trace_dump_arg(uint, type);
|
|
|
|
pipe->create_fence_fd(pipe, fence, fd, type);
|
|
|
|
if (fence)
|
|
trace_dump_ret(ptr, *fence);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_fence_server_sync(struct pipe_context *_pipe,
|
|
struct pipe_fence_handle *fence)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "fence_server_sync");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, fence);
|
|
|
|
pipe->fence_server_sync(pipe, fence);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
|
|
static inline bool
|
|
trace_context_generate_mipmap(struct pipe_context *_pipe,
|
|
struct pipe_resource *res,
|
|
enum pipe_format format,
|
|
unsigned base_level,
|
|
unsigned last_level,
|
|
unsigned first_layer,
|
|
unsigned last_layer)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
bool ret;
|
|
|
|
trace_dump_call_begin("pipe_context", "generate_mipmap");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, res);
|
|
|
|
trace_dump_arg(format, format);
|
|
trace_dump_arg(uint, base_level);
|
|
trace_dump_arg(uint, last_level);
|
|
trace_dump_arg(uint, first_layer);
|
|
trace_dump_arg(uint, last_layer);
|
|
|
|
ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level,
|
|
first_layer, last_layer);
|
|
|
|
trace_dump_ret(bool, ret);
|
|
trace_dump_call_end();
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_destroy(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", "destroy");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_call_end();
|
|
|
|
pipe->destroy(pipe);
|
|
|
|
ralloc_free(tr_ctx);
|
|
}
|
|
|
|
|
|
/********************************************************************
|
|
* transfer
|
|
*/
|
|
|
|
|
|
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 pipe_context *context = tr_context->pipe;
|
|
struct pipe_transfer *result = NULL;
|
|
void *map;
|
|
|
|
/*
|
|
* Map and transfers can't be serialized so we convert all write transfers
|
|
* to texture/buffer_subdata and ignore read transfers.
|
|
*/
|
|
|
|
map = context->transfer_map(context, resource, level, usage, box, &result);
|
|
if (!map)
|
|
return NULL;
|
|
|
|
*transfer = trace_transfer_create(tr_context, resource, result);
|
|
|
|
if (map) {
|
|
if (usage & PIPE_MAP_WRITE) {
|
|
trace_transfer(*transfer)->map = map;
|
|
}
|
|
}
|
|
|
|
return *transfer ? map : NULL;
|
|
}
|
|
|
|
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;
|
|
|
|
context->transfer_flush_region(context, transfer, box);
|
|
}
|
|
|
|
static void
|
|
trace_context_transfer_unmap(struct pipe_context *_context,
|
|
struct pipe_transfer *_transfer)
|
|
{
|
|
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;
|
|
|
|
if (tr_trans->map) {
|
|
/*
|
|
* Fake a texture/buffer_subdata
|
|
*/
|
|
|
|
struct pipe_resource *resource = transfer->resource;
|
|
unsigned usage = transfer->usage;
|
|
const struct pipe_box *box = &transfer->box;
|
|
unsigned stride = transfer->stride;
|
|
unsigned layer_stride = transfer->layer_stride;
|
|
|
|
if (resource->target == PIPE_BUFFER) {
|
|
unsigned offset = box->x;
|
|
unsigned size = box->width;
|
|
|
|
trace_dump_call_begin("pipe_context", "buffer_subdata");
|
|
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(ptr, resource);
|
|
trace_dump_arg(uint, usage);
|
|
trace_dump_arg(uint, offset);
|
|
trace_dump_arg(uint, size);
|
|
|
|
trace_dump_arg_begin("data");
|
|
trace_dump_box_bytes(tr_trans->map,
|
|
resource,
|
|
box,
|
|
stride,
|
|
layer_stride);
|
|
trace_dump_arg_end();
|
|
|
|
trace_dump_arg(uint, stride);
|
|
trace_dump_arg(uint, layer_stride);
|
|
|
|
trace_dump_call_end();
|
|
} else {
|
|
unsigned level = transfer->level;
|
|
|
|
trace_dump_call_begin("pipe_context", "texture_subdata");
|
|
|
|
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,
|
|
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;
|
|
}
|
|
|
|
context->transfer_unmap(context, transfer);
|
|
trace_transfer_destroy(tr_ctx, tr_trans);
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_buffer_subdata(struct pipe_context *_context,
|
|
struct pipe_resource *resource,
|
|
unsigned usage, unsigned offset,
|
|
unsigned size, const void *data)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
struct pipe_box box;
|
|
|
|
trace_dump_call_begin("pipe_context", "buffer_subdata");
|
|
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(ptr, resource);
|
|
trace_dump_arg(uint, usage);
|
|
trace_dump_arg(uint, offset);
|
|
trace_dump_arg(uint, size);
|
|
|
|
trace_dump_arg_begin("data");
|
|
u_box_1d(offset, size, &box);
|
|
trace_dump_box_bytes(data, resource, &box, 0, 0);
|
|
trace_dump_arg_end();
|
|
|
|
trace_dump_call_end();
|
|
|
|
context->buffer_subdata(context, resource, usage, offset, size, data);
|
|
}
|
|
|
|
|
|
static void
|
|
trace_context_texture_subdata(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 pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "texture_subdata");
|
|
|
|
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,
|
|
box,
|
|
stride,
|
|
layer_stride);
|
|
trace_dump_arg_end();
|
|
|
|
trace_dump_arg(uint, stride);
|
|
trace_dump_arg(uint, layer_stride);
|
|
|
|
trace_dump_call_end();
|
|
|
|
context->texture_subdata(context, resource, level, usage, box,
|
|
data, stride, layer_stride);
|
|
}
|
|
|
|
static void
|
|
trace_context_invalidate_resource(struct pipe_context *_context,
|
|
struct pipe_resource *resource)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "invalidate_resource");
|
|
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(ptr, resource);
|
|
|
|
trace_dump_call_end();
|
|
|
|
context->invalidate_resource(context, resource);
|
|
}
|
|
|
|
static void
|
|
trace_context_set_context_param(struct pipe_context *_context,
|
|
enum pipe_context_param param,
|
|
unsigned value)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_context_param");
|
|
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(uint, param);
|
|
trace_dump_arg(uint, value);
|
|
|
|
trace_dump_call_end();
|
|
|
|
context->set_context_param(context, param, value);
|
|
}
|
|
|
|
static void
|
|
trace_context_render_condition(struct pipe_context *_context,
|
|
struct pipe_query *query,
|
|
bool condition,
|
|
enum pipe_render_cond_flag 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, unsigned flags)
|
|
{
|
|
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_arg(uint, flags);
|
|
|
|
trace_dump_call_end();
|
|
|
|
context->texture_barrier(context, flags);
|
|
}
|
|
|
|
|
|
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 bool
|
|
trace_context_resource_commit(struct pipe_context *_context,
|
|
struct pipe_resource *resource,
|
|
unsigned level, struct pipe_box *box, bool commit)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "resource_commit");
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(ptr, resource);
|
|
trace_dump_arg(uint, level);
|
|
trace_dump_arg(box, box);
|
|
trace_dump_arg(bool, commit);
|
|
trace_dump_call_end();
|
|
|
|
return context->resource_commit(context, resource, level, box, commit);
|
|
}
|
|
|
|
static void
|
|
trace_context_set_tess_state(struct pipe_context *_context,
|
|
const float default_outer_level[4],
|
|
const float default_inner_level[2])
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_tess_state");
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg_array(float, default_outer_level, 4);
|
|
trace_dump_arg_array(float, default_inner_level, 2);
|
|
trace_dump_call_end();
|
|
|
|
context->set_tess_state(context, default_outer_level, default_inner_level);
|
|
}
|
|
|
|
|
|
static void trace_context_set_shader_buffers(struct pipe_context *_context,
|
|
enum pipe_shader_type shader,
|
|
unsigned start, unsigned nr,
|
|
const struct pipe_shader_buffer *buffers,
|
|
unsigned writable_bitmask)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_shader_buffers");
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(uint, shader);
|
|
trace_dump_arg(uint, start);
|
|
trace_dump_arg_begin("buffers");
|
|
trace_dump_struct_array(shader_buffer, buffers, nr);
|
|
trace_dump_arg_end();
|
|
trace_dump_arg(uint, writable_bitmask);
|
|
trace_dump_call_end();
|
|
|
|
context->set_shader_buffers(context, shader, start, nr, buffers,
|
|
writable_bitmask);
|
|
}
|
|
|
|
static void trace_context_set_shader_images(struct pipe_context *_context,
|
|
enum pipe_shader_type shader,
|
|
unsigned start, unsigned nr,
|
|
unsigned unbind_num_trailing_slots,
|
|
const struct pipe_image_view *images)
|
|
{
|
|
struct trace_context *tr_context = trace_context(_context);
|
|
struct pipe_context *context = tr_context->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "set_shader_images");
|
|
trace_dump_arg(ptr, context);
|
|
trace_dump_arg(uint, shader);
|
|
trace_dump_arg(uint, start);
|
|
trace_dump_arg_begin("images");
|
|
trace_dump_struct_array(image_view, images, nr);
|
|
trace_dump_arg_end();
|
|
trace_dump_arg(uint, unbind_num_trailing_slots);
|
|
trace_dump_call_end();
|
|
|
|
context->set_shader_images(context, shader, start, nr,
|
|
unbind_num_trailing_slots, images);
|
|
}
|
|
|
|
static void trace_context_launch_grid(struct pipe_context *_pipe,
|
|
const struct pipe_grid_info *info)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "launch_grid");
|
|
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(grid_info, info);
|
|
|
|
trace_dump_trace_flush();
|
|
|
|
pipe->launch_grid(pipe, info);
|
|
|
|
trace_dump_call_end();
|
|
}
|
|
|
|
static uint64_t trace_context_create_texture_handle(struct pipe_context *_pipe,
|
|
struct pipe_sampler_view *view,
|
|
const struct pipe_sampler_state *state)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
uint64_t handle;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_texture_handle");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(ptr, view);
|
|
trace_dump_arg_begin("state");
|
|
trace_dump_arg(sampler_state, state);
|
|
trace_dump_arg_end();
|
|
|
|
handle = pipe->create_texture_handle(pipe, view, state);
|
|
|
|
trace_dump_ret(uint, handle);
|
|
trace_dump_call_end();
|
|
|
|
return handle;
|
|
}
|
|
|
|
static void trace_context_delete_texture_handle(struct pipe_context *_pipe,
|
|
uint64_t handle)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "delete_texture_handle");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, handle);
|
|
trace_dump_call_end();
|
|
|
|
pipe->delete_texture_handle(pipe, handle);
|
|
}
|
|
|
|
static void trace_context_make_texture_handle_resident(struct pipe_context *_pipe,
|
|
uint64_t handle,
|
|
bool resident)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "make_texture_handle_resident");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, handle);
|
|
trace_dump_arg(bool, resident);
|
|
trace_dump_call_end();
|
|
|
|
pipe->make_texture_handle_resident(pipe, handle, resident);
|
|
}
|
|
|
|
static uint64_t trace_context_create_image_handle(struct pipe_context *_pipe,
|
|
const struct pipe_image_view *image)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
uint64_t handle;
|
|
|
|
trace_dump_call_begin("pipe_context", "create_image_handle");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg_begin("image");
|
|
trace_dump_image_view(image);
|
|
trace_dump_arg_end();
|
|
|
|
handle = pipe->create_image_handle(pipe, image);
|
|
|
|
trace_dump_ret(uint, handle);
|
|
trace_dump_call_end();
|
|
|
|
return handle;
|
|
}
|
|
|
|
static void trace_context_delete_image_handle(struct pipe_context *_pipe,
|
|
uint64_t handle)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "delete_image_handle");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, handle);
|
|
trace_dump_call_end();
|
|
|
|
pipe->delete_image_handle(pipe, handle);
|
|
}
|
|
|
|
static void trace_context_make_image_handle_resident(struct pipe_context *_pipe,
|
|
uint64_t handle,
|
|
unsigned access,
|
|
bool resident)
|
|
{
|
|
struct trace_context *tr_ctx = trace_context(_pipe);
|
|
struct pipe_context *pipe = tr_ctx->pipe;
|
|
|
|
trace_dump_call_begin("pipe_context", "make_image_handle_resident");
|
|
trace_dump_arg(ptr, pipe);
|
|
trace_dump_arg(uint, handle);
|
|
trace_dump_arg(uint, access);
|
|
trace_dump_arg(bool, resident);
|
|
trace_dump_call_end();
|
|
|
|
pipe->make_image_handle_resident(pipe, handle, access, resident);
|
|
}
|
|
|
|
struct pipe_context *
|
|
trace_context_create(struct trace_screen *tr_scr,
|
|
struct pipe_context *pipe)
|
|
{
|
|
struct trace_context *tr_ctx;
|
|
|
|
if (!pipe)
|
|
goto error1;
|
|
|
|
if (!trace_enabled())
|
|
goto error1;
|
|
|
|
tr_ctx = ralloc(NULL, struct trace_context);
|
|
if (!tr_ctx)
|
|
goto error1;
|
|
|
|
_mesa_hash_table_init(&tr_ctx->blend_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
|
|
_mesa_hash_table_init(&tr_ctx->rasterizer_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
|
|
_mesa_hash_table_init(&tr_ctx->depth_stencil_alpha_states, tr_ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
|
|
|
|
tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
|
|
tr_ctx->base.screen = &tr_scr->base;
|
|
tr_ctx->base.stream_uploader = pipe->stream_uploader;
|
|
tr_ctx->base.const_uploader = pipe->const_uploader;
|
|
|
|
tr_ctx->base.destroy = trace_context_destroy;
|
|
|
|
#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(set_active_query_state);
|
|
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_tcs_state);
|
|
TR_CTX_INIT(bind_tcs_state);
|
|
TR_CTX_INIT(delete_tcs_state);
|
|
TR_CTX_INIT(create_tes_state);
|
|
TR_CTX_INIT(bind_tes_state);
|
|
TR_CTX_INIT(delete_tes_state);
|
|
TR_CTX_INIT(create_compute_state);
|
|
TR_CTX_INIT(bind_compute_state);
|
|
TR_CTX_INIT(delete_compute_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_inlinable_constants);
|
|
TR_CTX_INIT(set_polygon_stipple);
|
|
TR_CTX_INIT(set_min_samples);
|
|
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(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(clear_texture);
|
|
TR_CTX_INIT(flush);
|
|
TR_CTX_INIT(create_fence_fd);
|
|
TR_CTX_INIT(fence_server_sync);
|
|
TR_CTX_INIT(generate_mipmap);
|
|
TR_CTX_INIT(texture_barrier);
|
|
TR_CTX_INIT(memory_barrier);
|
|
TR_CTX_INIT(resource_commit);
|
|
TR_CTX_INIT(set_tess_state);
|
|
TR_CTX_INIT(set_shader_buffers);
|
|
TR_CTX_INIT(launch_grid);
|
|
TR_CTX_INIT(set_shader_images);
|
|
TR_CTX_INIT(create_texture_handle);
|
|
TR_CTX_INIT(delete_texture_handle);
|
|
TR_CTX_INIT(make_texture_handle_resident);
|
|
TR_CTX_INIT(create_image_handle);
|
|
TR_CTX_INIT(delete_image_handle);
|
|
TR_CTX_INIT(make_image_handle_resident);
|
|
|
|
TR_CTX_INIT(transfer_map);
|
|
TR_CTX_INIT(transfer_unmap);
|
|
TR_CTX_INIT(transfer_flush_region);
|
|
TR_CTX_INIT(buffer_subdata);
|
|
TR_CTX_INIT(texture_subdata);
|
|
TR_CTX_INIT(invalidate_resource);
|
|
TR_CTX_INIT(set_context_param);
|
|
|
|
#undef TR_CTX_INIT
|
|
|
|
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)
|
|
{
|
|
ASSERTED struct trace_context *tr_ctx = (struct trace_context *) pipe;
|
|
assert(tr_ctx->base.destroy == trace_context_destroy);
|
|
}
|