which should create a gallium.*.trace file, which is an XML file. You can view
copying trace.xsl and trace.css to the same directory, and opening with a
-XSLT capable browser like Firefox or Internet Explorer. It often happens that
-the trace file was not properly terminated, and a
-
- </trace>
-
-closing tag is missing from the file end. Add it before try to open or
-further transform it by doing
-
- echo '</trace>' >> gallium.??.trace
-
+XSLT capable browser like Firefox or Internet Explorer.
This is still work in progress, namely:
- surface writes are not traced
**************************************************************************/
#include "pipe/p_util.h"
+#include "pipe/p_screen.h"
-#include "tr_stream.h"
#include "tr_dump.h"
#include "tr_state.h"
-#include "tr_winsys.h"
-#include "tr_screen.h"
#include "tr_context.h"
const unsigned *bitfield)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_edgeflags");
+ trace_dump_call_begin("pipe_context", "set_edgeflags");
- trace_dump_arg(stream, ptr, pipe);
+ trace_dump_arg(ptr, pipe);
/* FIXME: we don't know how big this array is */
- trace_dump_arg(stream, ptr, bitfield);
+ trace_dump_arg(ptr, bitfield);
pipe->set_edgeflags(pipe, bitfield);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned mode, unsigned start, unsigned count)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
boolean result;
- trace_dump_call_begin(stream, "pipe_context", "draw_arrays");
+ trace_dump_call_begin("pipe_context", "draw_arrays");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, mode);
- trace_dump_arg(stream, uint, start);
- trace_dump_arg(stream, uint, count);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, mode);
+ trace_dump_arg(uint, start);
+ trace_dump_arg(uint, count);
result = pipe->draw_arrays(pipe, mode, start, count);;
- trace_dump_ret(stream, bool, result);
+ trace_dump_ret(bool, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned mode, unsigned start, unsigned count)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
boolean result;
- trace_dump_call_begin(stream, "pipe_context", "draw_elements");
+ trace_dump_call_begin("pipe_context", "draw_elements");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, indexBuffer);
- trace_dump_arg(stream, uint, indexSize);
- trace_dump_arg(stream, uint, mode);
- trace_dump_arg(stream, uint, start);
- trace_dump_arg(stream, uint, count);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, indexBuffer);
+ trace_dump_arg(uint, indexSize);
+ trace_dump_arg(uint, mode);
+ trace_dump_arg(uint, start);
+ trace_dump_arg(uint, count);
result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);;
- trace_dump_ret(stream, bool, result);
+ trace_dump_ret(bool, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned count)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
boolean result;
- trace_dump_call_begin(stream, "pipe_context", "draw_range_elements");
+ trace_dump_call_begin("pipe_context", "draw_range_elements");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, indexBuffer);
- trace_dump_arg(stream, uint, indexSize);
- trace_dump_arg(stream, uint, minIndex);
- trace_dump_arg(stream, uint, maxIndex);
- trace_dump_arg(stream, uint, mode);
- trace_dump_arg(stream, uint, start);
- trace_dump_arg(stream, uint, count);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, indexBuffer);
+ trace_dump_arg(uint, indexSize);
+ trace_dump_arg(uint, minIndex);
+ trace_dump_arg(uint, maxIndex);
+ trace_dump_arg(uint, mode);
+ trace_dump_arg(uint, start);
+ trace_dump_arg(uint, count);
result = pipe->draw_range_elements(pipe,
indexBuffer,
indexSize, minIndex, maxIndex,
mode, start, count);
- trace_dump_ret(stream, bool, result);
+ trace_dump_ret(bool, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned query_type)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
struct pipe_query *result;
- trace_dump_call_begin(stream, "pipe_context", "create_query");
+ trace_dump_call_begin("pipe_context", "create_query");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, query_type);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, query_type);
result = pipe->create_query(pipe, query_type);;
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_query *query)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "destroy_query");
+ trace_dump_call_begin("pipe_context", "destroy_query");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, query);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, query);
pipe->destroy_query(pipe, query);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
struct pipe_query *query)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "begin_query");
+ trace_dump_call_begin("pipe_context", "begin_query");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, query);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, query);
pipe->begin_query(pipe, query);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
struct pipe_query *query)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "end_query");
+ trace_dump_call_begin("pipe_context", "end_query");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, query);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, query);
pipe->end_query(pipe, query);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
uint64 *presult)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
uint64 result;
boolean _result;
- trace_dump_call_begin(stream, "pipe_context", "get_query_result");
+ trace_dump_call_begin("pipe_context", "get_query_result");
- trace_dump_arg(stream, ptr, pipe);
+ trace_dump_arg(ptr, pipe);
_result = pipe->get_query_result(pipe, query, wait, presult);;
result = *presult;
- trace_dump_arg(stream, uint, result);
- trace_dump_ret(stream, bool, _result);
+ trace_dump_arg(uint, result);
+ trace_dump_ret(bool, _result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return _result;
}
const struct pipe_blend_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_blend_state");
+ trace_dump_call_begin("pipe_context", "create_blend_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, blend_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(blend_state, state);
result = pipe->create_blend_state(pipe, state);;
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_blend_state");
+ trace_dump_call_begin("pipe_context", "bind_blend_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->bind_blend_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_blend_state");
+ trace_dump_call_begin("pipe_context", "delete_blend_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_blend_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_sampler_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_sampler_state");
+ trace_dump_call_begin("pipe_context", "create_sampler_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
result = pipe->create_sampler_state(pipe, state);;
- trace_dump_ret(stream, sampler_state, result);
+ trace_dump_ret(sampler_state, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned num_states, void **states)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_sampler_states");
+ trace_dump_call_begin("pipe_context", "bind_sampler_states");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, num_states);
- trace_dump_arg_array(stream, ptr, states, num_states);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, num_states);
+ trace_dump_arg_array(ptr, states, num_states);
pipe->bind_sampler_states(pipe, num_states, states);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_sampler_state");
+ trace_dump_call_begin("pipe_context", "delete_sampler_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_sampler_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_rasterizer_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_rasterizer_state");
+ trace_dump_call_begin("pipe_context", "create_rasterizer_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, rasterizer_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(rasterizer_state, state);
result = pipe->create_rasterizer_state(pipe, state);;
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_rasterizer_state");
+ trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->bind_rasterizer_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_rasterizer_state");
+ trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_rasterizer_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_depth_stencil_alpha_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_depth_stencil_alpha_state");
+ trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
result = pipe->create_depth_stencil_alpha_state(pipe, state);;
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, depth_stencil_alpha_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(depth_stencil_alpha_state, state);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_depth_stencil_alpha_state");
+ trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->bind_depth_stencil_alpha_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_depth_stencil_alpha_state");
+ trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_depth_stencil_alpha_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_shader_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_fs_state");
+ trace_dump_call_begin("pipe_context", "create_fs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, shader_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(shader_state, state);
result = pipe->create_fs_state(pipe, state);;
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_fs_state");
+ trace_dump_call_begin("pipe_context", "bind_fs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->bind_fs_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_fs_state");
+ trace_dump_call_begin("pipe_context", "delete_fs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_fs_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_shader_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
void * result;
- trace_dump_call_begin(stream, "pipe_context", "create_vs_state");
+ trace_dump_call_begin("pipe_context", "create_vs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, shader_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(shader_state, state);
result = pipe->create_vs_state(pipe, state);;
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "bind_vs_state");
+ trace_dump_call_begin("pipe_context", "bind_vs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->bind_vs_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
void *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "delete_vs_state");
+ trace_dump_call_begin("pipe_context", "delete_vs_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, state);
pipe->delete_vs_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_blend_color *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_blend_color");
+ trace_dump_call_begin("pipe_context", "set_blend_color");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, blend_color, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(blend_color, state);
pipe->set_blend_color(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_clip_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_clip_state");
+ trace_dump_call_begin("pipe_context", "set_clip_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, clip_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(clip_state, state);
pipe->set_clip_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_constant_buffer *buffer)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_constant_buffer");
+ trace_dump_call_begin("pipe_context", "set_constant_buffer");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, shader);
- trace_dump_arg(stream, uint, index);
- trace_dump_arg(stream, constant_buffer, buffer);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, shader);
+ trace_dump_arg(uint, index);
+ trace_dump_arg(constant_buffer, buffer);
pipe->set_constant_buffer(pipe, shader, index, buffer);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_framebuffer_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_framebuffer_state");
+ trace_dump_call_begin("pipe_context", "set_framebuffer_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, framebuffer_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(framebuffer_state, state);
pipe->set_framebuffer_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_poly_stipple *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_polygon_stipple");
+ trace_dump_call_begin("pipe_context", "set_polygon_stipple");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, poly_stipple, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(poly_stipple, state);
pipe->set_polygon_stipple(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_scissor_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_scissor_state");
+ trace_dump_call_begin("pipe_context", "set_scissor_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, scissor_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(scissor_state, state);
pipe->set_scissor_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_viewport_state *state)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_viewport_state");
+ trace_dump_call_begin("pipe_context", "set_viewport_state");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, viewport_state, state);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(viewport_state, state);
pipe->set_viewport_state(pipe, state);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
struct pipe_texture **textures)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_sampler_textures");
+ trace_dump_call_begin("pipe_context", "set_sampler_textures");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, num_textures);
- trace_dump_arg_array(stream, ptr, textures, num_textures);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, num_textures);
+ trace_dump_arg_array(ptr, textures, num_textures);
pipe->set_sampler_textures(pipe, num_textures, textures);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_vertex_buffer *buffers)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_vertex_buffers");
+ trace_dump_call_begin("pipe_context", "set_vertex_buffers");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, num_buffers);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, num_buffers);
- trace_dump_arg_begin(stream, "buffers");
- trace_dump_struct_array(stream, vertex_buffer, buffers, num_buffers);
- trace_dump_arg_end(stream);
+ trace_dump_arg_begin("buffers");
+ trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
+ trace_dump_arg_end();
pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
const struct pipe_vertex_element *elements)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "set_vertex_elements");
+ trace_dump_call_begin("pipe_context", "set_vertex_elements");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, num_elements);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, num_elements);
- trace_dump_arg_begin(stream, "elements");
- trace_dump_struct_array(stream, vertex_element, elements, num_elements);
- trace_dump_arg_end(stream);
+ trace_dump_arg_begin("elements");
+ trace_dump_struct_array(vertex_element, elements, num_elements);
+ trace_dump_arg_end();
pipe->set_vertex_elements(pipe, num_elements, elements);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned width, unsigned height)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "surface_copy");
+ trace_dump_call_begin("pipe_context", "surface_copy");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, bool, do_flip);
- trace_dump_arg(stream, ptr, dest);
- trace_dump_arg(stream, uint, destx);
- trace_dump_arg(stream, uint, desty);
- trace_dump_arg(stream, ptr, src);
- trace_dump_arg(stream, uint, srcx);
- trace_dump_arg(stream, uint, srcy);
- trace_dump_arg(stream, uint, width);
- trace_dump_arg(stream, uint, height);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(bool, do_flip);
+ 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);
pipe->surface_copy(pipe, do_flip,
dest, destx, desty,
src, srcx, srcy, width, height);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned value)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "surface_fill");
+ trace_dump_call_begin("pipe_context", "surface_fill");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, dst);
- trace_dump_arg(stream, uint, dstx);
- trace_dump_arg(stream, uint, dsty);
- trace_dump_arg(stream, uint, width);
- trace_dump_arg(stream, uint, height);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, dst);
+ trace_dump_arg(uint, dstx);
+ trace_dump_arg(uint, dsty);
+ trace_dump_arg(uint, width);
+ trace_dump_arg(uint, height);
pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned clearValue)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "clear");
+ trace_dump_call_begin("pipe_context", "clear");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, ptr, surface);
- trace_dump_arg(stream, uint, clearValue);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(ptr, surface);
+ trace_dump_arg(uint, clearValue);
pipe->clear(pipe, surface, clearValue);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
struct pipe_fence_handle **fence)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "flush");
+ trace_dump_call_begin("pipe_context", "flush");
- trace_dump_arg(stream, ptr, pipe);
- trace_dump_arg(stream, uint, flags);
- trace_dump_arg(stream, ptr, fence);
+ trace_dump_arg(ptr, pipe);
+ trace_dump_arg(uint, flags);
+ trace_dump_arg(ptr, fence);
pipe->flush(pipe, flags, fence);;
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
trace_context_destroy(struct pipe_context *_pipe)
{
struct trace_context *tr_ctx = trace_context(_pipe);
- struct trace_stream *stream = tr_ctx->stream;
struct pipe_context *pipe = tr_ctx->pipe;
- trace_dump_call_begin(stream, "pipe_context", "destroy");
+ trace_dump_call_begin("pipe_context", "destroy");
- trace_dump_arg(stream, ptr, pipe);
+ trace_dump_arg(ptr, pipe);
pipe->destroy(pipe);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
FREE(tr_ctx);
}
trace_context_create(struct pipe_screen *screen,
struct pipe_context *pipe)
{
- struct trace_stream *stream;
struct trace_context *tr_ctx;
- if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
- return pipe;
+ if(!pipe)
+ goto error1;
tr_ctx = CALLOC_STRUCT(trace_context);
if(!tr_ctx)
- return NULL;
+ goto error1;
tr_ctx->base.winsys = screen->winsys;
tr_ctx->base.screen = screen;
tr_ctx->base.flush = trace_context_flush;
tr_ctx->pipe = pipe;
- tr_ctx->stream = stream = trace_screen(screen)->stream;
- trace_dump_call_begin(stream, "", "pipe_context_create");
- trace_dump_arg_begin(stream, "screen");
- trace_dump_ptr(stream, pipe->screen);
- trace_dump_arg_end(stream);
- trace_dump_ret(stream, ptr, pipe);
- trace_dump_call_end(stream);
+ trace_dump_call_begin("", "pipe_context_create");
+ trace_dump_arg_begin("screen");
+ trace_dump_ptr(pipe->screen);
+ trace_dump_arg_end();
+ trace_dump_ret(ptr, pipe);
+ trace_dump_call_end();
return &tr_ctx->base;
+
+error1:
+ return pipe;
}
#include "pipe/p_context.h"
-struct trace_stream;
-
-
struct trace_context
{
struct pipe_context base;
struct pipe_context *pipe;
-
- struct trace_stream *stream;
};
* @author Jose Fonseca <jrfonseca@tungstengraphics.com>
*/
+#include "pipe/p_config.h"
+
+#if defined(PIPE_OS_LINUX)
+#include <stdlib.h>
+#endif
#include "pipe/p_compiler.h"
#include "util/u_string.h"
#include "tr_dump.h"
+static struct trace_stream *stream = NULL;
+
+
static INLINE void
-trace_dump_write(struct trace_stream *stream, const char *s)
+trace_dump_write(const char *buf, size_t size)
{
- trace_stream_write(stream, s, strlen(s));
+ if(stream)
+ trace_stream_write(stream, buf, size);
}
static INLINE void
-trace_dump_writef(struct trace_stream *stream, const char *format, ...)
+trace_dump_writes(const char *s)
{
- char buf[1024];
+ trace_dump_write(s, strlen(s));
+}
+
+
+static INLINE void
+trace_dump_writef(const char *format, ...)
+{
+ static char buf[1024];
+ unsigned len;
va_list ap;
va_start(ap, format);
- util_vsnprintf(buf, sizeof(buf), format, ap);
+ len = util_vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
- trace_dump_write(stream, buf);
+ trace_dump_write(buf, len);
}
static INLINE void
-trace_dump_escape(struct trace_stream *stream, const char *str)
+trace_dump_escape(const char *str)
{
const unsigned char *p = (const unsigned char *)str;
unsigned char c;
while((c = *p++) != 0) {
if(c == '<')
- trace_dump_write(stream, "<");
+ trace_dump_writes("<");
else if(c == '>')
- trace_dump_write(stream, ">");
+ trace_dump_writes(">");
else if(c == '&')
- trace_dump_write(stream, "&");
+ trace_dump_writes("&");
else if(c == '\'')
- trace_dump_write(stream, "'");
+ trace_dump_writes("'");
else if(c == '\"')
- trace_dump_write(stream, """);
+ trace_dump_writes(""");
else if(c >= 0x20 && c <= 0x7e)
- trace_dump_writef(stream, "%c", c);
+ trace_dump_writef("%c", c);
else
- trace_dump_writef(stream, "&#%u;", c);
+ trace_dump_writef("&#%u;", c);
}
}
static INLINE void
-trace_dump_indent(struct trace_stream *stream, unsigned level)
+trace_dump_indent(unsigned level)
{
unsigned i;
for(i = 0; i < level; ++i)
- trace_dump_write(stream, "\t");
+ trace_dump_writes("\t");
}
static INLINE void
-trace_dump_newline(struct trace_stream *stream)
+trace_dump_newline(void)
{
- trace_dump_write(stream, "\n");
+ trace_dump_writes("\n");
}
static INLINE void
-trace_dump_tag(struct trace_stream *stream,
- const char *name)
+trace_dump_tag(const char *name)
{
- trace_dump_write(stream, "<");
- trace_dump_write(stream, name);
- trace_dump_write(stream, "/>");
+ trace_dump_writes("<");
+ trace_dump_writes(name);
+ trace_dump_writes("/>");
}
static INLINE void
-trace_dump_tag_begin(struct trace_stream *stream,
- const char *name)
+trace_dump_tag_begin(const char *name)
{
- trace_dump_write(stream, "<");
- trace_dump_write(stream, name);
- trace_dump_write(stream, ">");
+ trace_dump_writes("<");
+ trace_dump_writes(name);
+ trace_dump_writes(">");
}
static INLINE void
-trace_dump_tag_begin1(struct trace_stream *stream,
- const char *name,
+trace_dump_tag_begin1(const char *name,
const char *attr1, const char *value1)
{
- trace_dump_write(stream, "<");
- trace_dump_write(stream, name);
- trace_dump_write(stream, " ");
- trace_dump_write(stream, attr1);
- trace_dump_write(stream, "='");
- trace_dump_escape(stream, value1);
- trace_dump_write(stream, "'>");
+ trace_dump_writes("<");
+ trace_dump_writes(name);
+ trace_dump_writes(" ");
+ trace_dump_writes(attr1);
+ trace_dump_writes("='");
+ trace_dump_escape(value1);
+ trace_dump_writes("'>");
}
static INLINE void
-trace_dump_tag_begin2(struct trace_stream *stream,
- const char *name,
+trace_dump_tag_begin2(const char *name,
const char *attr1, const char *value1,
const char *attr2, const char *value2)
{
- trace_dump_write(stream, "<");
- trace_dump_write(stream, name);
- trace_dump_write(stream, " ");
- trace_dump_write(stream, attr1);
- trace_dump_write(stream, "=\'");
- trace_dump_escape(stream, value1);
- trace_dump_write(stream, "\' ");
- trace_dump_write(stream, attr2);
- trace_dump_write(stream, "=\'");
- trace_dump_escape(stream, value2);
- trace_dump_write(stream, "\'>");
+ trace_dump_writes("<");
+ trace_dump_writes(name);
+ trace_dump_writes(" ");
+ trace_dump_writes(attr1);
+ trace_dump_writes("=\'");
+ trace_dump_escape(value1);
+ trace_dump_writes("\' ");
+ trace_dump_writes(attr2);
+ trace_dump_writes("=\'");
+ trace_dump_escape(value2);
+ trace_dump_writes("\'>");
}
static INLINE void
-trace_dump_tag_begin3(struct trace_stream *stream,
- const char *name,
+trace_dump_tag_begin3(const char *name,
const char *attr1, const char *value1,
const char *attr2, const char *value2,
const char *attr3, const char *value3)
{
- trace_dump_write(stream, "<");
- trace_dump_write(stream, name);
- trace_dump_write(stream, " ");
- trace_dump_write(stream, attr1);
- trace_dump_write(stream, "=\'");
- trace_dump_escape(stream, value1);
- trace_dump_write(stream, "\' ");
- trace_dump_write(stream, attr2);
- trace_dump_write(stream, "=\'");
- trace_dump_escape(stream, value2);
- trace_dump_write(stream, "\' ");
- trace_dump_write(stream, attr3);
- trace_dump_write(stream, "=\'");
- trace_dump_escape(stream, value3);
- trace_dump_write(stream, "\'>");
+ trace_dump_writes("<");
+ trace_dump_writes(name);
+ trace_dump_writes(" ");
+ trace_dump_writes(attr1);
+ trace_dump_writes("=\'");
+ trace_dump_escape(value1);
+ trace_dump_writes("\' ");
+ trace_dump_writes(attr2);
+ trace_dump_writes("=\'");
+ trace_dump_escape(value2);
+ trace_dump_writes("\' ");
+ trace_dump_writes(attr3);
+ trace_dump_writes("=\'");
+ trace_dump_escape(value3);
+ trace_dump_writes("\'>");
}
static INLINE void
-trace_dump_tag_end(struct trace_stream *stream,
- const char *name)
-{
- trace_dump_write(stream, "</");
- trace_dump_write(stream, name);
- trace_dump_write(stream, ">");
-}
-
-
-void trace_dump_trace_begin(struct trace_stream *stream,
- unsigned version)
-{
- trace_dump_write(stream, "<?xml version='1.0' encoding='UTF-8'?>\n");
- trace_dump_write(stream, "<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
- trace_dump_writef(stream, "<trace version='%u'>\n", version);
-}
-
-
-void trace_dump_trace_end(struct trace_stream *stream)
-{
- trace_dump_write(stream, "</trace>\n");
+trace_dump_tag_end(const char *name)
+{
+ trace_dump_writes("</");
+ trace_dump_writes(name);
+ trace_dump_writes(">");
+}
+
+boolean trace_dump_trace_begin()
+{
+ if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
+ return FALSE;
+
+ stream = trace_stream_create("gallium", "trace");
+ if(!stream)
+ return FALSE;
+
+ trace_dump_writes("<?xml version='1.0' encoding='UTF-8'?>\n");
+ trace_dump_writes("<?xml-stylesheet type='text/xsl' href='trace.xsl'?>\n");
+ trace_dump_writes("<trace version='0.1'>\n");
+
+#if defined(PIPE_OS_LINUX)
+ /* Linux applications rarely cleanup GL / Gallium resources so catch
+ * application exit here */
+ atexit(trace_dump_trace_end);
+#endif
+
+ return TRUE;
+}
+
+void trace_dump_trace_end(void)
+{
+ if(stream) {
+ trace_dump_writes("</trace>\n");
+ trace_stream_close(stream);
+ stream = NULL;
+ }
}
-void trace_dump_call_begin(struct trace_stream *stream,
- const char *klass, const char *method)
+void trace_dump_call_begin(const char *klass, const char *method)
{
- trace_dump_indent(stream, 1);
- trace_dump_tag_begin2(stream, "call", "class", klass, "method", method);
- trace_dump_newline(stream);
+ trace_dump_indent(1);
+ trace_dump_tag_begin2("call", "class", klass, "method", method);
+ trace_dump_newline();
}
-void trace_dump_call_end(struct trace_stream *stream)
+void trace_dump_call_end(void)
{
- trace_dump_indent(stream, 1);
- trace_dump_tag_end(stream, "call");
- trace_dump_newline(stream);
+ trace_dump_indent(1);
+ trace_dump_tag_end("call");
+ trace_dump_newline();
}
-void trace_dump_arg_begin(struct trace_stream *stream,
- const char *name)
+void trace_dump_arg_begin(const char *name)
{
- trace_dump_indent(stream, 2);
- trace_dump_tag_begin1(stream, "arg", "name", name);
+ trace_dump_indent(2);
+ trace_dump_tag_begin1("arg", "name", name);
}
-void trace_dump_arg_end(struct trace_stream *stream)
+void trace_dump_arg_end(void)
{
- trace_dump_tag_end(stream, "arg");
- trace_dump_newline(stream);
+ trace_dump_tag_end("arg");
+ trace_dump_newline();
}
-void trace_dump_ret_begin(struct trace_stream *stream)
+void trace_dump_ret_begin(void)
{
- trace_dump_indent(stream, 2);
- trace_dump_tag_begin(stream, "ret");
+ trace_dump_indent(2);
+ trace_dump_tag_begin("ret");
}
-void trace_dump_ret_end(struct trace_stream *stream)
+void trace_dump_ret_end(void)
{
- trace_dump_tag_end(stream, "ret");
- trace_dump_newline(stream);
+ trace_dump_tag_end("ret");
+ trace_dump_newline();
}
-void trace_dump_bool(struct trace_stream *stream,
- int value)
+void trace_dump_bool(int value)
{
- trace_dump_writef(stream, "<bool>%c</bool>", value ? '1' : '0');
+ trace_dump_writef("<bool>%c</bool>", value ? '1' : '0');
}
-void trace_dump_int(struct trace_stream *stream,
- long int value)
+void trace_dump_int(long int value)
{
- trace_dump_writef(stream, "<int>%li</int>", value);
+ trace_dump_writef("<int>%li</int>", value);
}
-void trace_dump_uint(struct trace_stream *stream,
- long unsigned value)
+void trace_dump_uint(long unsigned value)
{
- trace_dump_writef(stream, "<uint>%lu</uint>", value);
+ trace_dump_writef("<uint>%lu</uint>", value);
}
-void trace_dump_float(struct trace_stream *stream,
- double value)
+void trace_dump_float(double value)
{
- trace_dump_writef(stream, "<float>%g</float>", value);
+ trace_dump_writef("<float>%g</float>", value);
}
-void trace_dump_bytes(struct trace_stream *stream,
- const void *data,
+void trace_dump_bytes(const void *data,
long unsigned size)
{
static const char hex_table[16] = "0123456789ABCDEF";
const uint8_t *p = data;
long unsigned i;
- trace_dump_write(stream, "<bytes>");
+ trace_dump_writes("<bytes>");
for(i = 0; i < size; ++i) {
uint8_t byte = *p++;
char hex[2];
hex[0] = hex_table[byte >> 4];
hex[1] = hex_table[byte & 0xf];
- trace_stream_write(stream, hex, 2);
+ trace_dump_write(hex, 2);
}
- trace_dump_write(stream, "</bytes>");
+ trace_dump_writes("</bytes>");
}
-void trace_dump_string(struct trace_stream *stream,
- const char *str)
+void trace_dump_string(const char *str)
{
- trace_dump_write(stream, "<string>");
- trace_dump_escape(stream, str);
- trace_dump_write(stream, "</string>");
+ trace_dump_writes("<string>");
+ trace_dump_escape(str);
+ trace_dump_writes("</string>");
}
-void trace_dump_enum(struct trace_stream *stream,
- const char *value)
+void trace_dump_enum(const char *value)
{
- trace_dump_write(stream, "<enum>");
- trace_dump_escape(stream, value);
- trace_dump_write(stream, "</enum>");
+ trace_dump_writes("<enum>");
+ trace_dump_escape(value);
+ trace_dump_writes("</enum>");
}
-void trace_dump_array_begin(struct trace_stream *stream)
+void trace_dump_array_begin(void)
{
- trace_dump_write
(stream, "<array>");
+ trace_dump_write
s("<array>");
}
-void trace_dump_array_end(struct trace_stream *stream)
+void trace_dump_array_end(void)
{
- trace_dump_write(stream, "</array>");
+ trace_dump_writes("</array>");
}
-void trace_dump_elem_begin(struct trace_stream *stream)
+void trace_dump_elem_begin(void)
{
- trace_dump_write(stream, "<elem>");
+ trace_dump_writes("<elem>");
}
-void trace_dump_elem_end(struct trace_stream *stream)
+void trace_dump_elem_end(void)
{
- trace_dump_write(stream, "</elem>");
+ trace_dump_writes("</elem>");
}
-void trace_dump_struct_begin(struct trace_stream *stream,
- const char *name)
+void trace_dump_struct_begin(const char *name)
{
- trace_dump_writef(stream, "<struct name='%s'>", name);
+ trace_dump_writef("<struct name='%s'>", name);
}
-void trace_dump_struct_end(struct trace_stream *stream)
+void trace_dump_struct_end(void)
{
- trace_dump_write(stream, "</struct>");
+ trace_dump_writes("</struct>");
}
-void trace_dump_member_begin(struct trace_stream *stream,
- const char *name)
+void trace_dump_member_begin(const char *name)
{
- trace_dump_writef(stream, "<member name='%s'>", name);
+ trace_dump_writef("<member name='%s'>", name);
}
-void trace_dump_member_end(struct trace_stream *stream)
+void trace_dump_member_end(void)
{
- trace_dump_write(stream, "</member>");
+ trace_dump_writes("</member>");
}
-void trace_dump_null(struct trace_stream *stream)
+void trace_dump_null(void)
{
- trace_dump_write(stream, "<null/>");
+ trace_dump_writes("<null/>");
}
-void trace_dump_ptr(struct trace_stream *stream,
- const void *value)
+void trace_dump_ptr(const void *value)
{
if(value)
- trace_dump_writef(
stream, "<ptr>%p</ptr>", value);
+ trace_dump_writef("<ptr>%p</ptr>", value);
else
- trace_dump_null(stream);
+ trace_dump_null();
}
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * 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
#define TR_DUMP_H
+#include "pipe/p_compiler.h"
#include "pipe/p_util.h"
-struct trace_stream;
-
-
-void trace_dump_trace_begin(struct trace_stream *stream, unsigned version);
-void trace_dump_trace_end(struct trace_stream *stream);
-void trace_dump_call_begin(struct trace_stream *stream, const char *klass, const char *method);
-void trace_dump_call_end(struct trace_stream *stream);
-void trace_dump_arg_begin(struct trace_stream *stream, const char *name);
-void trace_dump_arg_end(struct trace_stream *stream);
-void trace_dump_ret_begin(struct trace_stream *stream);
-void trace_dump_ret_end(struct trace_stream *stream);
-void trace_dump_bool(struct trace_stream *stream, int value);
-void trace_dump_int(struct trace_stream *stream, long int value);
-void trace_dump_uint(struct trace_stream *stream, long unsigned value);
-void trace_dump_float(struct trace_stream *stream, double value);
-void trace_dump_bytes(struct trace_stream *stream, const void *data, long unsigned size);
-void trace_dump_string(struct trace_stream *stream, const char *str);
-void trace_dump_enum(struct trace_stream *stream, const char *value);
-void trace_dump_array_begin(struct trace_stream *stream);
-void trace_dump_array_end(struct trace_stream *stream);
-void trace_dump_elem_begin(struct trace_stream *stream);
-void trace_dump_elem_end(struct trace_stream *stream);
-void trace_dump_struct_begin(struct trace_stream *stream, const char *name);
-void trace_dump_struct_end(struct trace_stream *stream);
-void trace_dump_member_begin(struct trace_stream *stream, const char *name);
-void trace_dump_member_end(struct trace_stream *stream);
-void trace_dump_null(struct trace_stream *stream);
-void trace_dump_ptr(struct trace_stream *stream, const void *value);
+boolean trace_dump_trace_begin(void);
+void trace_dump_trace_end(void);
+void trace_dump_call_begin(const char *klass, const char *method);
+void trace_dump_call_end(void);
+void trace_dump_arg_begin(const char *name);
+void trace_dump_arg_end(void);
+void trace_dump_ret_begin(void);
+void trace_dump_ret_end(void);
+void trace_dump_bool(int value);
+void trace_dump_int(long int value);
+void trace_dump_uint(long unsigned value);
+void trace_dump_float(double value);
+void trace_dump_bytes(const void *data, long unsigned size);
+void trace_dump_string(const char *str);
+void trace_dump_enum(const char *value);
+void trace_dump_array_begin(void);
+void trace_dump_array_end(void);
+void trace_dump_elem_begin(void);
+void trace_dump_elem_end(void);
+void trace_dump_struct_begin(const char *name);
+void trace_dump_struct_end(void);
+void trace_dump_member_begin(const char *name);
+void trace_dump_member_end(void);
+void trace_dump_null(void);
+void trace_dump_ptr(const void *value);
/*
* Code saving macros.
*/
-#define trace_dump_arg(_stream, _type, _arg) \
+#define trace_dump_arg(_type, _arg) \
do { \
- trace_dump_arg_begin(_stream, #_arg); \
- trace_dump_##_type(_stream, _arg); \
- trace_dump_arg_end(_stream); \
+ trace_dump_arg_begin(#_arg); \
+ trace_dump_##_type(_arg); \
+ trace_dump_arg_end(); \
} while(0)
-#define trace_dump_ret(_stream, _type, _arg) \
+#define trace_dump_ret(_type, _arg) \
do { \
- trace_dump_ret_begin(_stream); \
- trace_dump_##_type(_stream, _arg); \
- trace_dump_ret_end(_stream); \
+ trace_dump_ret_begin(); \
+ trace_dump_##_type(_arg); \
+ trace_dump_ret_end(); \
} while(0)
-#define trace_dump_array(_stream, _type, _obj, _size) \
+#define trace_dump_array(_type, _obj, _size) \
do { \
unsigned long idx; \
- trace_dump_array_begin(_stream); \
+ trace_dump_array_begin(); \
for(idx = 0; idx < (_size); ++idx) { \
- trace_dump_elem_begin(_stream); \
- trace_dump_##_type(_stream, (_obj)[idx]); \
- trace_dump_elem_end(_stream); \
+ trace_dump_elem_begin(); \
+ trace_dump_##_type((_obj)[idx]); \
+ trace_dump_elem_end(); \
} \
- trace_dump_array_end(_stream); \
+ trace_dump_array_end(); \
} while(0)
-#define trace_dump_struct_array(_stream, _type, _obj, _size) \
+#define trace_dump_struct_array(_type, _obj, _size) \
do { \
unsigned long idx; \
- trace_dump_array_begin(_stream); \
+ trace_dump_array_begin(); \
for(idx = 0; idx < (_size); ++idx) { \
- trace_dump_elem_begin(_stream); \
- trace_dump_##_type(_stream, &(_obj)[idx]); \
- trace_dump_elem_end(_stream); \
+ trace_dump_elem_begin(); \
+ trace_dump_##_type(&(_obj)[idx]); \
+ trace_dump_elem_end(); \
} \
- trace_dump_array_end(_stream); \
+ trace_dump_array_end(); \
} while(0)
-#define trace_dump_member(_stream, _type, _obj, _member) \
+#define trace_dump_member(_type, _obj, _member) \
do { \
- trace_dump_member_begin(_stream, #_member); \
- trace_dump_##_type(_stream, (_obj)->_member); \
- trace_dump_member_end(_stream); \
+ trace_dump_member_begin(#_member); \
+ trace_dump_##_type((_obj)->_member); \
+ trace_dump_member_end(); \
} while(0)
-#define trace_dump_arg_array(_stream, _type, _arg, _size) \
+#define trace_dump_arg_array(_type, _arg, _size) \
do { \
- trace_dump_arg_begin(_stream, #_arg); \
- trace_dump_array(_stream, _type, _arg, _size); \
- trace_dump_arg_end(_stream); \
+ trace_dump_arg_begin(#_arg); \
+ trace_dump_array(_type, _arg, _size); \
+ trace_dump_arg_end(); \
} while(0)
-#define trace_dump_member_array(_stream, _type, _obj, _member) \
+#define trace_dump_member_array(_type, _obj, _member) \
do { \
- trace_dump_member_begin(_stream, #_member); \
- trace_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
- trace_dump_member_end(_stream); \
+ trace_dump_member_begin(#_member); \
+ trace_dump_array(_type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
+ trace_dump_member_end(); \
} while(0)
#include "pipe/p_util.h"
-#include "tr_stream.h"
#include "tr_dump.h"
#include "tr_state.h"
#include "tr_winsys.h"
trace_screen_get_name(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
const char *result;
- trace_dump_call_begin(stream, "pipe_screen", "get_name");
+ trace_dump_call_begin("pipe_screen", "get_name");
- trace_dump_arg(stream, ptr, screen);
+ trace_dump_arg(ptr, screen);
result = screen->get_name(screen);
- trace_dump_ret(stream, string, result);
+ trace_dump_ret(string, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
trace_screen_get_vendor(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
const char *result;
- trace_dump_call_begin(stream, "pipe_screen", "get_vendor");
+ trace_dump_call_begin("pipe_screen", "get_vendor");
- trace_dump_arg(stream, ptr, screen);
+ trace_dump_arg(ptr, screen);
result = screen->get_vendor(screen);
- trace_dump_ret(stream, string, result);
+ trace_dump_ret(string, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
int param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
int result;
- trace_dump_call_begin(stream, "pipe_screen", "get_param");
+ trace_dump_call_begin("pipe_screen", "get_param");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, int, param);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(int, param);
result = screen->get_param(screen, param);
- trace_dump_ret(stream, int, result);
+ trace_dump_ret(int, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
int param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
float result;
- trace_dump_call_begin(stream, "pipe_screen", "get_paramf");
+ trace_dump_call_begin("pipe_screen", "get_paramf");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, int, param);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(int, param);
result = screen->get_paramf(screen, param);
- trace_dump_ret(stream, float, result);
+ trace_dump_ret(float, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned geom_flags)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
boolean result;
- trace_dump_call_begin(stream, "pipe_screen", "is_format_supported");
+ trace_dump_call_begin("pipe_screen", "is_format_supported");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, format, format);
- trace_dump_arg(stream, int, target);
- trace_dump_arg(stream, uint, tex_usage);
- trace_dump_arg(stream, uint, geom_flags);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(format, format);
+ trace_dump_arg(int, target);
+ trace_dump_arg(uint, tex_usage);
+ trace_dump_arg(uint, geom_flags);
result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
- trace_dump_ret(stream, bool, result);
+ trace_dump_ret(bool, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
const struct pipe_texture *templat)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_texture *result;
- trace_dump_call_begin(stream, "pipe_screen", "texture_create");
+ trace_dump_call_begin("pipe_screen", "texture_create");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, template, templat);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(template, templat);
result = screen->texture_create(screen, templat);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_buffer *buffer)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
unsigned pitch = *ppitch;
struct pipe_texture *result;
- trace_dump_call_begin(stream, "pipe_screen", "texture_blanket");
+ trace_dump_call_begin("pipe_screen", "texture_blanket");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, template, templat);
- trace_dump_arg(stream, uint, pitch);
- trace_dump_arg(stream, ptr, buffer);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(template, templat);
+ trace_dump_arg(uint, pitch);
+ trace_dump_arg(ptr, buffer);
result = screen->texture_blanket(screen, templat, ppitch, buffer);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_texture **ptexture)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_texture *texture = *ptexture;
- trace_dump_call_begin(stream, "pipe_screen", "texture_release");
+ trace_dump_call_begin("pipe_screen", "texture_release");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, ptr, texture);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, texture);
screen->texture_release(screen, ptexture);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
static struct pipe_surface *
unsigned usage)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *result;
- trace_dump_call_begin(stream, "pipe_screen", "get_tex_surface");
+ trace_dump_call_begin("pipe_screen", "get_tex_surface");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, ptr, texture);
- trace_dump_arg(stream, uint, face);
- trace_dump_arg(stream, uint, level);
- trace_dump_arg(stream, uint, zslice);
- trace_dump_arg(stream, uint, usage);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, texture);
+ trace_dump_arg(uint, face);
+ trace_dump_arg(uint, level);
+ trace_dump_arg(uint, zslice);
+ trace_dump_arg(uint, usage);
result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_surface **psurface)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *surface = *psurface;
- trace_dump_call_begin(stream, "pipe_screen", "tex_surface_release");
+ trace_dump_call_begin("pipe_screen", "tex_surface_release");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, ptr, surface);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, surface);
screen->tex_surface_release(screen, psurface);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned flags)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *result;
- trace_dump_call_begin(stream, "pipe_screen", "surface_map");
+ trace_dump_call_begin("pipe_screen", "surface_map");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, ptr, surface);
- trace_dump_arg(stream, uint, flags);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, surface);
+ trace_dump_arg(uint, flags);
result = screen->surface_map(screen, surface, flags);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_surface *surface)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
- trace_dump_call_begin(stream, "pipe_screen", "surface_unmap");
+ trace_dump_call_begin("pipe_screen", "surface_unmap");
- trace_dump_arg(stream, ptr, screen);
- trace_dump_arg(stream, ptr, surface);
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, surface);
screen->surface_unmap(screen, surface);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
trace_screen_destroy(struct pipe_screen *_screen)
{
struct trace_screen *tr_scr = trace_screen(_screen);
- struct trace_stream *stream = tr_scr->stream;
struct pipe_screen *screen = tr_scr->screen;
- trace_dump_call_begin(stream, "pipe_screen", "destroy");
+ trace_dump_call_begin("pipe_screen", "destroy");
- trace_dump_arg(stream, ptr, screen);
+ trace_dump_arg(ptr, screen);
screen->destroy(screen);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
- trace_dump_trace_end(stream);
-
- trace_stream_close(stream);
+ trace_dump_trace_end();
FREE(tr_scr);
}
struct pipe_screen *
trace_screen_create(struct pipe_screen *screen)
{
- struct trace_stream *stream;
struct trace_screen *tr_scr;
struct pipe_winsys *winsys;
- if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
- return screen;
-
- tr_scr = CALLOC_STRUCT(trace_screen);
- if(!tr_scr)
- return NULL;
+ if(!screen)
+ goto error1;
- tr_scr->stream = stream = trace_stream_create("gallium", "trace");
- if(!tr_scr->stream)
- return NULL;
+ if(!trace_dump_trace_begin())
+ goto error1;
- trace_dump_trace_begin(stream, 0);
+ tr_scr = CALLOC_STRUCT(trace_screen);
+ if(!tr_scr)
+ goto error2;
- winsys = trace_winsys_create(stream, screen->winsys);
+ winsys = trace_winsys_create(screen->winsys);
if(!winsys)
- return NULL;
+ goto error3;
tr_scr->base.winsys = winsys;
tr_scr->base.destroy = trace_screen_destroy;
tr_scr->base.surface_unmap = trace_screen_surface_unmap;
tr_scr->screen = screen;
- tr_scr->stream = stream = trace_winsys(winsys)->stream;
- trace_dump_call_begin(stream, "", "pipe_screen_create");
- trace_dump_arg_begin(stream, "winsys");
- trace_dump_ptr(stream, screen->winsys);
- trace_dump_arg_end(stream);
- trace_dump_ret(stream, ptr, screen);
- trace_dump_call_end(stream);
+ trace_dump_call_begin("", "pipe_screen_create");
+ trace_dump_arg_begin("winsys");
+ trace_dump_ptr(screen->winsys);
+ trace_dump_arg_end();
+ trace_dump_ret(ptr, screen);
+ trace_dump_call_end();
return &tr_scr->base;
+
+error3:
+ FREE(tr_scr);
+error2:
+ trace_dump_trace_end();
+error1:
+ return screen;
}
#include "pipe/p_screen.h"
-struct trace_stream;
-
-
struct trace_screen
{
struct pipe_screen base;
struct pipe_screen *screen;
-
- struct trace_stream *stream;
};
#include "tr_state.h"
-void trace_dump_format(struct trace_stream *stream,
- enum pipe_format format)
+void trace_dump_format(enum pipe_format format)
{
- trace_dump_enum(stream, pf_name(format) );
+ trace_dump_enum(pf_name(format) );
}
-void trace_dump_block(struct trace_stream *stream,
- const struct pipe_format_block *block)
+void trace_dump_block(const struct pipe_format_block *block)
{
- trace_dump_struct_begin(stream, "pipe_format_block");
- trace_dump_member(stream, uint, block, size);
- trace_dump_member(stream, uint, block, width);
- trace_dump_member(stream, uint, block, height);
- trace_dump_struct_end(stream);
+ trace_dump_struct_begin("pipe_format_block");
+ trace_dump_member(uint, block, size);
+ trace_dump_member(uint, block, width);
+ trace_dump_member(uint, block, height);
+ trace_dump_struct_end();
}
-void trace_dump_template(struct trace_stream *stream,
- const struct pipe_texture *templat)
+void trace_dump_template(const struct pipe_texture *templat)
{
assert(templat);
if(!templat) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_texture");
+ trace_dump_struct_begin("pipe_texture");
- trace_dump_member(stream, int, templat, target);
- trace_dump_member(stream, format, templat, format);
+ trace_dump_member(int, templat, target);
+ trace_dump_member(format, templat, format);
- trace_dump_member_begin(stream, "width");
- trace_dump_array(stream, uint, templat->width, 1);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("width");
+ trace_dump_array(uint, templat->width, 1);
+ trace_dump_member_end();
- trace_dump_member_begin(stream, "height");
- trace_dump_array(stream, uint, templat->height, 1);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("height");
+ trace_dump_array(uint, templat->height, 1);
+ trace_dump_member_end();
- trace_dump_member_begin(stream, "depth");
- trace_dump_array(stream, uint, templat->depth, 1);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("depth");
+ trace_dump_array(uint, templat->depth, 1);
+ trace_dump_member_end();
- trace_dump_member_begin(stream, "block");
- trace_dump_block(stream, &templat->block);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("block");
+ trace_dump_block(&templat->block);
+ trace_dump_member_end();
- trace_dump_member(stream, uint, templat, last_level);
- trace_dump_member(stream, uint, templat, tex_usage);
+ trace_dump_member(uint, templat, last_level);
+ trace_dump_member(uint, templat, tex_usage);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_rasterizer_state(struct trace_stream *stream,
- const struct pipe_rasterizer_state *state)
+void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_rasterizer_state");
-
- trace_dump_member(stream, bool, state, flatshade);
- trace_dump_member(stream, bool, state, light_twoside);
- trace_dump_member(stream, uint, state, front_winding);
- trace_dump_member(stream, uint, state, cull_mode);
- trace_dump_member(stream, uint, state, fill_cw);
- trace_dump_member(stream, uint, state, fill_ccw);
- trace_dump_member(stream, bool, state, offset_cw);
- trace_dump_member(stream, bool, state, offset_ccw);
- trace_dump_member(stream, bool, state, scissor);
- trace_dump_member(stream, bool, state, poly_smooth);
- trace_dump_member(stream, bool, state, poly_stipple_enable);
- trace_dump_member(stream, bool, state, point_smooth);
- trace_dump_member(stream, bool, state, point_sprite);
- trace_dump_member(stream, bool, state, point_size_per_vertex);
- trace_dump_member(stream, bool, state, multisample);
- trace_dump_member(stream, bool, state, line_smooth);
- trace_dump_member(stream, bool, state, line_stipple_enable);
- trace_dump_member(stream, uint, state, line_stipple_factor);
- trace_dump_member(stream, uint, state, line_stipple_pattern);
- trace_dump_member(stream, bool, state, line_last_pixel);
- trace_dump_member(stream, bool, state, bypass_clipping);
- trace_dump_member(stream, bool, state, bypass_vs);
- trace_dump_member(stream, bool, state, origin_lower_left);
- trace_dump_member(stream, bool, state, flatshade_first);
- trace_dump_member(stream, bool, state, gl_rasterization_rules);
-
- trace_dump_member(stream, float, state, line_width);
- trace_dump_member(stream, float, state, point_size);
- trace_dump_member(stream, float, state, point_size_min);
- trace_dump_member(stream, float, state, point_size_max);
- trace_dump_member(stream, float, state, offset_units);
- trace_dump_member(stream, float, state, offset_scale);
+ trace_dump_struct_begin("pipe_rasterizer_state");
+
+ trace_dump_member(bool, state, flatshade);
+ trace_dump_member(bool, state, light_twoside);
+ trace_dump_member(uint, state, front_winding);
+ trace_dump_member(uint, state, cull_mode);
+ trace_dump_member(uint, state, fill_cw);
+ trace_dump_member(uint, state, fill_ccw);
+ trace_dump_member(bool, state, offset_cw);
+ trace_dump_member(bool, state, offset_ccw);
+ trace_dump_member(bool, state, scissor);
+ trace_dump_member(bool, state, poly_smooth);
+ trace_dump_member(bool, state, poly_stipple_enable);
+ trace_dump_member(bool, state, point_smooth);
+ trace_dump_member(bool, state, point_sprite);
+ trace_dump_member(bool, state, point_size_per_vertex);
+ trace_dump_member(bool, state, multisample);
+ trace_dump_member(bool, state, line_smooth);
+ trace_dump_member(bool, state, line_stipple_enable);
+ trace_dump_member(uint, state, line_stipple_factor);
+ trace_dump_member(uint, state, line_stipple_pattern);
+ trace_dump_member(bool, state, line_last_pixel);
+ trace_dump_member(bool, state, bypass_clipping);
+ trace_dump_member(bool, state, bypass_vs);
+ trace_dump_member(bool, state, origin_lower_left);
+ trace_dump_member(bool, state, flatshade_first);
+ trace_dump_member(bool, state, gl_rasterization_rules);
+
+ trace_dump_member(float, state, line_width);
+ trace_dump_member(float, state, point_size);
+ trace_dump_member(float, state, point_size_min);
+ trace_dump_member(float, state, point_size_max);
+ trace_dump_member(float, state, offset_units);
+ trace_dump_member(float, state, offset_scale);
- trace_dump_member_array(stream, uint, state, sprite_coord_mode);
+ trace_dump_member_array(uint, state, sprite_coord_mode);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_poly_stipple(struct trace_stream *stream,
- const struct pipe_poly_stipple *state)
+void trace_dump_poly_stipple(const struct pipe_poly_stipple *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_poly_stipple");
+ trace_dump_struct_begin("pipe_poly_stipple");
- trace_dump_member_begin(stream, "stipple");
- trace_dump_array(stream,
- uint,
+ trace_dump_member_begin("stipple");
+ trace_dump_array(uint,
state->stipple,
Elements(state->stipple));
- trace_dump_member_end(stream);
+ trace_dump_member_end();
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_viewport_state(struct trace_stream *stream,
- const struct pipe_viewport_state *state)
+void trace_dump_viewport_state(const struct pipe_viewport_state *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_viewport_state");
+ trace_dump_struct_begin("pipe_viewport_state");
- trace_dump_member_array(stream, float, state, scale);
- trace_dump_member_array(stream, float, state, translate);
+ trace_dump_member_array(float, state, scale);
+ trace_dump_member_array(float, state, translate);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_scissor_state(struct trace_stream *stream,
- const struct pipe_scissor_state *state)
+void trace_dump_scissor_state(const struct pipe_scissor_state *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_scissor_state");
+ trace_dump_struct_begin("pipe_scissor_state");
- trace_dump_member(stream, uint, state, minx);
- trace_dump_member(stream, uint, state, miny);
- trace_dump_member(stream, uint, state, maxx);
- trace_dump_member(stream, uint, state, maxy);
+ trace_dump_member(uint, state, minx);
+ trace_dump_member(uint, state, miny);
+ trace_dump_member(uint, state, maxx);
+ trace_dump_member(uint, state, maxy);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_clip_state(struct trace_stream *stream,
- const struct pipe_clip_state *state)
+void trace_dump_clip_state(const struct pipe_clip_state *state)
{
unsigned i;
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_scissor_state");
+ trace_dump_struct_begin("pipe_scissor_state");
- trace_dump_member_begin(stream, "ucp");
- trace_dump_array_begin(stream);
+ trace_dump_member_begin("ucp");
+ trace_dump_array_begin();
for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i)
- trace_dump_array(stream, float, state->ucp[i], 4);
- trace_dump_array_end(stream);
- trace_dump_member_end(stream);
+ trace_dump_array(float, state->ucp[i], 4);
+ trace_dump_array_end();
+ trace_dump_member_end();
- trace_dump_member(stream, uint, state, nr);
+ trace_dump_member(uint, state, nr);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_constant_buffer(struct trace_stream *stream,
- const struct pipe_constant_buffer *state)
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_constant_buffer");
+ trace_dump_struct_begin("pipe_constant_buffer");
- trace_dump_member(stream, ptr, state, buffer);
- trace_dump_member(stream, uint, state, size);
+ trace_dump_member(ptr, state, buffer);
+ trace_dump_member(uint, state, size);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_shader_state(struct trace_stream *stream,
- const struct pipe_shader_state *state)
+void trace_dump_shader_state(const struct pipe_shader_state *state)
{
static char str[8192];
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
tgsi_dump_str(state->tokens, 0, str, sizeof(str));
- trace_dump_struct_begin(stream, "pipe_shader_state");
+ trace_dump_struct_begin("pipe_shader_state");
- trace_dump_member_begin(stream, "tokens");
- trace_dump_string(stream, str);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("tokens");
+ trace_dump_string(str);
+ trace_dump_member_end();
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
- const struct pipe_depth_stencil_alpha_state *state)
+void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state)
{
unsigned i;
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
+ trace_dump_struct_begin("pipe_depth_stencil_alpha_state");
- trace_dump_member_begin(stream, "depth");
- trace_dump_struct_begin(stream, "pipe_depth_state");
- trace_dump_member(stream, bool, &state->depth, enabled);
- trace_dump_member(stream, bool, &state->depth, writemask);
- trace_dump_member(stream, uint, &state->depth, func);
- trace_dump_member(stream, bool, &state->depth, occlusion_count);
- trace_dump_struct_end(stream);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("depth");
+ trace_dump_struct_begin("pipe_depth_state");
+ trace_dump_member(bool, &state->depth, enabled);
+ trace_dump_member(bool, &state->depth, writemask);
+ trace_dump_member(uint, &state->depth, func);
+ trace_dump_member(bool, &state->depth, occlusion_count);
+ trace_dump_struct_end();
+ trace_dump_member_end();
- trace_dump_member_begin(stream, "stencil");
- trace_dump_array_begin(stream);
+ trace_dump_member_begin("stencil");
+ trace_dump_array_begin();
for(i = 0; i < Elements(state->stencil); ++i) {
- trace_dump_elem_begin(stream);
- trace_dump_struct_begin(stream, "pipe_stencil_state");
- trace_dump_member(stream, bool, &state->stencil[i], enabled);
- trace_dump_member(stream, uint, &state->stencil[i], func);
- trace_dump_member(stream, uint, &state->stencil[i], fail_op);
- trace_dump_member(stream, uint, &state->stencil[i], zpass_op);
- trace_dump_member(stream, uint, &state->stencil[i], zfail_op);
- trace_dump_member(stream, uint, &state->stencil[i], ref_value);
- trace_dump_member(stream, uint, &state->stencil[i], value_mask);
- trace_dump_member(stream, uint, &state->stencil[i], write_mask);
- trace_dump_struct_end(stream);
- trace_dump_elem_end(stream);
+ trace_dump_elem_begin();
+ trace_dump_struct_begin("pipe_stencil_state");
+ trace_dump_member(bool, &state->stencil[i], enabled);
+ trace_dump_member(uint, &state->stencil[i], func);
+ trace_dump_member(uint, &state->stencil[i], fail_op);
+ trace_dump_member(uint, &state->stencil[i], zpass_op);
+ trace_dump_member(uint, &state->stencil[i], zfail_op);
+ trace_dump_member(uint, &state->stencil[i], ref_value);
+ trace_dump_member(uint, &state->stencil[i], value_mask);
+ trace_dump_member(uint, &state->stencil[i], write_mask);
+ trace_dump_struct_end();
+ trace_dump_elem_end();
}
- trace_dump_array_end(stream);
- trace_dump_member_end(stream);
-
- trace_dump_member_begin(stream, "alpha");
- trace_dump_struct_begin(stream, "pipe_alpha_state");
- trace_dump_member(stream, bool, &state->alpha, enabled);
- trace_dump_member(stream, uint, &state->alpha, func);
- trace_dump_member(stream, float, &state->alpha, ref);
- trace_dump_struct_end(stream);
- trace_dump_member_end(stream);
-
- trace_dump_struct_end(stream);
+ trace_dump_array_end();
+ trace_dump_member_end();
+
+ trace_dump_member_begin("alpha");
+ trace_dump_struct_begin("pipe_alpha_state");
+ trace_dump_member(bool, &state->alpha, enabled);
+ trace_dump_member(uint, &state->alpha, func);
+ trace_dump_member(float, &state->alpha, ref);
+ trace_dump_struct_end();
+ trace_dump_member_end();
+
+ trace_dump_struct_end();
}
-void trace_dump_blend_state(struct trace_stream *stream,
- const struct pipe_blend_state *state)
+void trace_dump_blend_state(const struct pipe_blend_state *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_blend_state");
+ trace_dump_struct_begin("pipe_blend_state");
- trace_dump_member(stream, bool, state, blend_enable);
+ trace_dump_member(bool, state, blend_enable);
- trace_dump_member(stream, uint, state, rgb_func);
- trace_dump_member(stream, uint, state, rgb_src_factor);
- trace_dump_member(stream, uint, state, rgb_dst_factor);
+ trace_dump_member(uint, state, rgb_func);
+ trace_dump_member(uint, state, rgb_src_factor);
+ trace_dump_member(uint, state, rgb_dst_factor);
- trace_dump_member(stream, uint, state, alpha_func);
- trace_dump_member(stream, uint, state, alpha_src_factor);
- trace_dump_member(stream, uint, state, alpha_dst_factor);
+ trace_dump_member(uint, state, alpha_func);
+ trace_dump_member(uint, state, alpha_src_factor);
+ trace_dump_member(uint, state, alpha_dst_factor);
- trace_dump_member(stream, bool, state, logicop_enable);
- trace_dump_member(stream, uint, state, logicop_func);
+ trace_dump_member(bool, state, logicop_enable);
+ trace_dump_member(uint, state, logicop_func);
- trace_dump_member(stream, uint, state, colormask);
- trace_dump_member(stream, bool, state, dither);
+ trace_dump_member(uint, state, colormask);
+ trace_dump_member(bool, state, dither);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_blend_color(struct trace_stream *stream,
- const struct pipe_blend_color *state)
+void trace_dump_blend_color(const struct pipe_blend_color *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_blend_color");
+ trace_dump_struct_begin("pipe_blend_color");
- trace_dump_member_array(stream, float, state, color);
+ trace_dump_member_array(float, state, color);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_framebuffer_state(struct trace_stream *stream,
- const struct pipe_framebuffer_state *state)
+void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state)
{
- trace_dump_struct_begin(stream, "pipe_framebuffer_state");
+ trace_dump_struct_begin("pipe_framebuffer_state");
- trace_dump_member(stream, uint, state, width);
- trace_dump_member(stream, uint, state, height);
- trace_dump_member(stream, uint, state, num_cbufs);
- trace_dump_member_array(stream, ptr, state, cbufs);
- trace_dump_member(stream, ptr, state, zsbuf);
+ trace_dump_member(uint, state, width);
+ trace_dump_member(uint, state, height);
+ trace_dump_member(uint, state, num_cbufs);
+ trace_dump_member_array(ptr, state, cbufs);
+ trace_dump_member(ptr, state, zsbuf);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_sampler_state(struct trace_stream *stream,
- const struct pipe_sampler_state *state)
+void trace_dump_sampler_state(const struct pipe_sampler_state *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_sampler_state");
-
- trace_dump_member(stream, uint, state, wrap_s);
- trace_dump_member(stream, uint, state, wrap_t);
- trace_dump_member(stream, uint, state, wrap_r);
- trace_dump_member(stream, uint, state, min_img_filter);
- trace_dump_member(stream, uint, state, min_mip_filter);
- trace_dump_member(stream, uint, state, mag_img_filter);
- trace_dump_member(stream, bool, state, compare_mode);
- trace_dump_member(stream, uint, state, compare_func);
- trace_dump_member(stream, bool, state, normalized_coords);
- trace_dump_member(stream, uint, state, prefilter);
- trace_dump_member(stream, float, state, shadow_ambient);
- trace_dump_member(stream, float, state, lod_bias);
- trace_dump_member(stream, float, state, min_lod);
- trace_dump_member(stream, float, state, max_lod);
- trace_dump_member_array(stream, float, state, border_color);
- trace_dump_member(stream, float, state, max_anisotropy);
-
- trace_dump_struct_end(stream);
+ trace_dump_struct_begin("pipe_sampler_state");
+
+ trace_dump_member(uint, state, wrap_s);
+ trace_dump_member(uint, state, wrap_t);
+ trace_dump_member(uint, state, wrap_r);
+ trace_dump_member(uint, state, min_img_filter);
+ trace_dump_member(uint, state, min_mip_filter);
+ trace_dump_member(uint, state, mag_img_filter);
+ trace_dump_member(bool, state, compare_mode);
+ trace_dump_member(uint, state, compare_func);
+ trace_dump_member(bool, state, normalized_coords);
+ trace_dump_member(uint, state, prefilter);
+ trace_dump_member(float, state, shadow_ambient);
+ trace_dump_member(float, state, lod_bias);
+ trace_dump_member(float, state, min_lod);
+ trace_dump_member(float, state, max_lod);
+ trace_dump_member_array(float, state, border_color);
+ trace_dump_member(float, state, max_anisotropy);
+
+ trace_dump_struct_end();
}
-void trace_dump_surface(struct trace_stream *stream,
- const struct pipe_surface *state)
+void trace_dump_surface(const struct pipe_surface *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_surface");
+ trace_dump_struct_begin("pipe_surface");
- trace_dump_member(stream, ptr, state, buffer);
- trace_dump_member(stream, format, state, format);
- trace_dump_member(stream, uint, state, status);
- trace_dump_member(stream, uint, state, clear_value);
- trace_dump_member(stream, uint, state, width);
- trace_dump_member(stream, uint, state, height);
+ trace_dump_member(ptr, state, buffer);
+ trace_dump_member(format, state, format);
+ trace_dump_member(uint, state, status);
+ trace_dump_member(uint, state, clear_value);
+ trace_dump_member(uint, state, width);
+ trace_dump_member(uint, state, height);
- trace_dump_member_begin(stream, "block");
- trace_dump_block(stream, &state->block);
- trace_dump_member_end(stream);
+ trace_dump_member_begin("block");
+ trace_dump_block(&state->block);
+ trace_dump_member_end();
- trace_dump_member(stream, uint, state, nblocksx);
- trace_dump_member(stream, uint, state, nblocksy);
- trace_dump_member(stream, uint, state, stride);
- trace_dump_member(stream, uint, state, layout);
- trace_dump_member(stream, uint, state, offset);
- trace_dump_member(stream, uint, state, refcount);
- trace_dump_member(stream, uint, state, usage);
-
- trace_dump_member(stream, ptr, state, texture);
- trace_dump_member(stream, uint, state, face);
- trace_dump_member(stream, uint, state, level);
- trace_dump_member(stream, uint, state, zslice);
-
- trace_dump_struct_end(stream);
+ trace_dump_member(uint, state, nblocksx);
+ trace_dump_member(uint, state, nblocksy);
+ trace_dump_member(uint, state, stride);
+ trace_dump_member(uint, state, layout);
+ trace_dump_member(uint, state, offset);
+ trace_dump_member(uint, state, refcount);
+ trace_dump_member(uint, state, usage);
+
+ trace_dump_member(ptr, state, texture);
+ trace_dump_member(uint, state, face);
+ trace_dump_member(uint, state, level);
+ trace_dump_member(uint, state, zslice);
+
+ trace_dump_struct_end();
}
-void trace_dump_vertex_buffer(struct trace_stream *stream,
- const struct pipe_vertex_buffer *state)
+void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_vertex_buffer");
+ trace_dump_struct_begin("pipe_vertex_buffer");
- trace_dump_member(stream, uint, state, pitch);
- trace_dump_member(stream, uint, state, max_index);
- trace_dump_member(stream, uint, state, buffer_offset);
- trace_dump_member(stream, ptr, state, buffer);
+ trace_dump_member(uint, state, pitch);
+ trace_dump_member(uint, state, max_index);
+ trace_dump_member(uint, state, buffer_offset);
+ trace_dump_member(ptr, state, buffer);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
-void trace_dump_vertex_element(struct trace_stream *stream,
- const struct pipe_vertex_element *state)
+void trace_dump_vertex_element(const struct pipe_vertex_element *state)
{
assert(state);
if(!state) {
- trace_dump_null(stream);
+ trace_dump_null();
return;
}
- trace_dump_struct_begin(stream, "pipe_vertex_element");
+ trace_dump_struct_begin("pipe_vertex_element");
- trace_dump_member(stream, uint, state, src_offset);
+ trace_dump_member(uint, state, src_offset);
- trace_dump_member(stream, uint, state, vertex_buffer_index);
- trace_dump_member(stream, uint, state, nr_components);
+ trace_dump_member(uint, state, vertex_buffer_index);
+ trace_dump_member(uint, state, nr_components);
- trace_dump_member(stream, format, state, src_format);
+ trace_dump_member(format, state, src_format);
- trace_dump_struct_end(stream);
+ trace_dump_struct_end();
}
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * 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
#include "pipe/p_shader_tokens.h"
-void trace_dump_format(struct trace_stream *stream,
- enum pipe_format format);
+void trace_dump_format(enum pipe_format format);
-void trace_dump_block(struct trace_stream *stream,
- const struct pipe_format_block *block);
+void trace_dump_block(const struct pipe_format_block *block);
-void trace_dump_template(struct trace_stream *stream,
- const struct pipe_texture *templat);
+void trace_dump_template(const struct pipe_texture *templat);
-void trace_dump_rasterizer_state(struct trace_stream *stream,
- const struct pipe_rasterizer_state *state);
+void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state);
-void trace_dump_poly_stipple(struct trace_stream *stream,
- const struct pipe_poly_stipple *state);
+void trace_dump_poly_stipple(const struct pipe_poly_stipple *state);
-void trace_dump_viewport_state(struct trace_stream *stream,
- const struct pipe_viewport_state *state);
+void trace_dump_viewport_state(const struct pipe_viewport_state *state);
-void trace_dump_scissor_state(struct trace_stream *stream,
- const struct pipe_scissor_state *state);
+void trace_dump_scissor_state(const struct pipe_scissor_state *state);
-void trace_dump_clip_state(struct trace_stream *stream,
- const struct pipe_clip_state *state);
+void trace_dump_clip_state(const struct pipe_clip_state *state);
-void trace_dump_constant_buffer(struct trace_stream *stream,
- const struct pipe_constant_buffer *state);
+void trace_dump_constant_buffer(const struct pipe_constant_buffer *state);
-void trace_dump_token(struct trace_stream *stream,
- const struct tgsi_token *token);
+void trace_dump_token(const struct tgsi_token *token);
-void trace_dump_shader_state(struct trace_stream *stream,
- const struct pipe_shader_state *state);
+void trace_dump_shader_state(const struct pipe_shader_state *state);
-void trace_dump_depth_stencil_alpha_state(struct trace_stream *stream,
- const struct pipe_depth_stencil_alpha_state *state);
+void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state);
-void trace_dump_blend_state(struct trace_stream *stream,
- const struct pipe_blend_state *state);
+void trace_dump_blend_state(const struct pipe_blend_state *state);
-void trace_dump_blend_color(struct trace_stream *stream,
- const struct pipe_blend_color *state);
+void trace_dump_blend_color(const struct pipe_blend_color *state);
-void trace_dump_framebuffer_state(struct trace_stream *stream,
- const struct pipe_framebuffer_state *state);
+void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state);
-void trace_dump_sampler_state(struct trace_stream *stream,
- const struct pipe_sampler_state *state);
+void trace_dump_sampler_state(const struct pipe_sampler_state *state);
-void trace_dump_surface(struct trace_stream *stream,
- const struct pipe_surface *state);
+void trace_dump_surface(const struct pipe_surface *state);
-void trace_dump_vertex_buffer(struct trace_stream *stream,
- const struct pipe_vertex_buffer *state);
+void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state);
-void trace_dump_vertex_element(struct trace_stream *stream,
- const struct pipe_vertex_element *state);
+void trace_dump_vertex_element(const struct pipe_vertex_element *state);
#endif /* TR_STATE_H */
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation streams (the
+ * 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
/**
* @file
* Cross-platform sequential access stream abstraction.
+ *
+ * These are really general purpose file access functions, and might one day
+ * be moved into the util module.
*/
#ifndef TR_STREAM_H
#include "pipe/p_state.h"
#include "util/u_hash_table.h"
-#include "tr_stream.h"
#include "tr_dump.h"
#include "tr_state.h"
#include "tr_winsys.h"
trace_winsys_get_name(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
const char *result;
- trace_dump_call_begin(stream, "pipe_winsys", "get_name");
+ trace_dump_call_begin("pipe_winsys", "get_name");
- trace_dump_arg(stream, ptr, winsys);
+ trace_dump_arg(ptr, winsys);
result = winsys->get_name(winsys);
- trace_dump_ret(stream, string, result);
+ trace_dump_ret(string, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
void *context_private)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
- trace_dump_call_begin(stream, "pipe_winsys", "flush_frontbuffer");
+ trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, surface);
- trace_dump_arg(stream, ptr, context_private);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, surface);
+ trace_dump_arg(ptr, context_private);
winsys->flush_frontbuffer(winsys, surface, context_private);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
trace_winsys_surface_alloc(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_surface *result;
- trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc");
+ trace_dump_call_begin("pipe_winsys", "surface_alloc");
- trace_dump_arg(stream, ptr, winsys);
+ trace_dump_arg(ptr, winsys);
result = winsys->surface_alloc(winsys);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned tex_usage)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
- trace_dump_call_begin(stream, "pipe_winsys", "surface_alloc_storage");
+ trace_dump_call_begin("pipe_winsys", "surface_alloc_storage");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, surface);
- trace_dump_arg(stream, uint, width);
- trace_dump_arg(stream, uint, height);
- trace_dump_arg(stream, format, format);
- trace_dump_arg(stream, uint, flags);
- trace_dump_arg(stream, uint, tex_usage);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, surface);
+ trace_dump_arg(uint, width);
+ trace_dump_arg(uint, height);
+ trace_dump_arg(format, format);
+ trace_dump_arg(uint, flags);
+ trace_dump_arg(uint, tex_usage);
result = winsys->surface_alloc_storage(winsys,
surface,
flags,
tex_usage);
- trace_dump_ret(stream, int, result);
+ trace_dump_ret(int, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_surface **psurface)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_surface *surface = *psurface;
- trace_dump_call_begin(stream, "pipe_winsys", "surface_release");
+ trace_dump_call_begin("pipe_winsys", "surface_release");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, surface);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, surface);
winsys->surface_release(winsys, psurface);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned size)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_buffer *buffer;
- trace_dump_call_begin(stream, "pipe_winsys", "buffer_create");
+ trace_dump_call_begin("pipe_winsys", "buffer_create");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, uint, alignment);
- trace_dump_arg(stream, uint, usage);
- trace_dump_arg(stream, uint, size);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(uint, alignment);
+ trace_dump_arg(uint, usage);
+ trace_dump_arg(uint, size);
buffer = winsys->buffer_create(winsys, alignment, usage, size);
- trace_dump_ret(stream, ptr, buffer);
+ trace_dump_ret(ptr, buffer);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
/* Zero the buffer to avoid dumping uninitialized memory */
if(buffer->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
unsigned bytes)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_buffer *result;
- trace_dump_call_begin(stream, "pipe_winsys", "user_buffer_create");
+ trace_dump_call_begin("pipe_winsys", "user_buffer_create");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, ptr);
- trace_dump_arg(stream, uint, bytes);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, ptr);
+ trace_dump_arg(uint, bytes);
result = winsys->user_buffer_create(winsys, ptr, bytes);
- trace_dump_ret(stream, ptr, result);
+ trace_dump_ret(ptr, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
struct pipe_buffer *buffer)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
const void *map;
map = hash_table_get(tr_ws->buffer_maps, buffer);
if(map) {
- trace_dump_call_begin(stream, "pipe_winsys", "buffer_write");
+ trace_dump_call_begin("pipe_winsys", "buffer_write");
- trace_dump_arg(stream, ptr, winsys);
+ trace_dump_arg(ptr, winsys);
- trace_dump_arg(stream, ptr, buffer);
+ trace_dump_arg(ptr, buffer);
- trace_dump_arg_begin(stream, "data");
- trace_dump_bytes(stream, map, buffer->size);
- trace_dump_arg_end(stream);
+ trace_dump_arg_begin("data");
+ trace_dump_bytes(map, buffer->size);
+ trace_dump_arg_end();
- trace_dump_arg_begin(stream, "size");
- trace_dump_uint(stream, buffer->size);
- trace_dump_arg_end(stream);
+ trace_dump_arg_begin("size");
+ trace_dump_uint(buffer->size);
+ trace_dump_arg_end();
- trace_dump_call_end(stream);
+ trace_dump_call_end();
hash_table_remove(tr_ws->buffer_maps, buffer);
}
struct pipe_buffer *buffer)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
- trace_dump_call_begin(stream, "pipe_winsys", "buffer_destroy");
+ trace_dump_call_begin("pipe_winsys", "buffer_destroy");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, buffer);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, buffer);
winsys->buffer_destroy(winsys, buffer);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
struct pipe_fence_handle *src)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
struct pipe_fence_handle *dst = *pdst;
- trace_dump_call_begin(stream, "pipe_winsys", "fence_reference");
+ trace_dump_call_begin("pipe_winsys", "fence_reference");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, dst);
- trace_dump_arg(stream, ptr, src);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, dst);
+ trace_dump_arg(ptr, src);
winsys->fence_reference(winsys, pdst, src);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
}
unsigned flag)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
- trace_dump_call_begin(stream, "pipe_winsys", "fence_signalled");
+ trace_dump_call_begin("pipe_winsys", "fence_signalled");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, fence);
- trace_dump_arg(stream, uint, flag);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, fence);
+ trace_dump_arg(uint, flag);
result = winsys->fence_signalled(winsys, fence, flag);
- trace_dump_ret(stream, int, result);
+ trace_dump_ret(int, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
unsigned flag)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
int result;
- trace_dump_call_begin(stream, "pipe_winsys", "fence_finish");
+ trace_dump_call_begin("pipe_winsys", "fence_finish");
- trace_dump_arg(stream, ptr, winsys);
- trace_dump_arg(stream, ptr, fence);
- trace_dump_arg(stream, uint, flag);
+ trace_dump_arg(ptr, winsys);
+ trace_dump_arg(ptr, fence);
+ trace_dump_arg(uint, flag);
result = winsys->fence_finish(winsys, fence, flag);
- trace_dump_ret(stream, int, result);
+ trace_dump_ret(int, result);
- trace_dump_call_end(stream);
+ trace_dump_call_end();
return result;
}
trace_winsys_destroy(struct pipe_winsys *_winsys)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
- struct trace_stream *stream = tr_ws->stream;
struct pipe_winsys *winsys = tr_ws->winsys;
- trace_dump_call_begin(stream, "pipe_winsys", "destroy");
+ trace_dump_call_begin("pipe_winsys", "destroy");
- trace_dump_arg(stream, ptr, winsys);
+ trace_dump_arg(ptr, winsys);
/*
winsys->destroy(winsys);
*/
- trace_dump_call_end(stream);
+ trace_dump_call_end();
hash_table_destroy(tr_ws->buffer_maps);
struct pipe_winsys *
-trace_winsys_create(struct trace_stream *stream,
- struct pipe_winsys *winsys)
+trace_winsys_create(struct pipe_winsys *winsys)
{
-
struct trace_winsys *tr_ws;
+ if(!winsys)
+ goto error1;
+
tr_ws = CALLOC_STRUCT(trace_winsys);
if(!tr_ws)
- return NULL;
+ goto error1;
tr_ws->base.destroy = trace_winsys_destroy;
tr_ws->base.get_name = trace_winsys_get_name;
tr_ws->base.fence_finish = trace_winsys_fence_finish;
tr_ws->winsys = winsys;
- tr_ws->stream = stream;
tr_ws->buffer_maps = hash_table_create(trace_buffer_hash,
trace_buffer_compare);
if(!tr_ws->buffer_maps)
- return NULL;
+ goto error2;
- trace_dump_call_begin(stream, "", "pipe_winsys_create");
- trace_dump_ret(stream, ptr, winsys);
- trace_dump_call_end(stream);
+ trace_dump_call_begin("", "pipe_winsys_create");
+ trace_dump_ret(ptr, winsys);
+ trace_dump_call_end();
return &tr_ws->base;
+
+error2:
+ FREE(tr_ws);
+error1:
+ return winsys;
}
struct hash_table;
-struct trace_stream;
struct trace_winsys
struct pipe_winsys *winsys;
- struct trace_stream *stream;
-
struct hash_table *buffer_maps;
};
struct pipe_winsys *
-trace_winsys_create(struct trace_stream *stream,
- struct pipe_winsys *winsys);
+trace_winsys_create(struct pipe_winsys *winsys);
#endif /* TR_WINSYS_H_ */
projects / mesa.git / commitdiff