1 /**************************************************************************
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "util/u_inlines.h"
29 #include "util/u_memory.h"
30 #include "util/u_simple_list.h"
31 #include "util/u_format.h"
33 #include "pipe/p_format.h"
34 #include "pipe/p_screen.h"
37 #include "tr_dump_state.h"
39 #include "tr_screen.h"
40 #include "tr_texture.h"
46 static INLINE struct pipe_resource *
47 trace_resource_unwrap(struct trace_context *tr_ctx,
48 struct pipe_resource *resource)
50 struct trace_resource *tr_tex;
55 tr_tex = trace_resource(resource);
57 assert(tr_tex->resource);
58 return tr_tex->resource;
62 static INLINE struct pipe_surface *
63 trace_surface_unwrap(struct trace_context *tr_ctx,
64 struct pipe_surface *surface)
66 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
67 struct trace_surface *tr_surf;
72 assert(surface->texture);
76 tr_surf = trace_surface(surface);
78 assert(tr_surf->surface);
79 assert(tr_surf->surface->texture->screen == tr_scr->screen);
81 return tr_surf->surface;
86 trace_context_draw_block(struct trace_context *tr_ctx, int flag)
90 pipe_mutex_lock(tr_ctx->draw_mutex);
92 if (tr_ctx->draw_blocker & flag) {
93 tr_ctx->draw_blocked |= flag;
94 } else if ((tr_ctx->draw_rule.blocker & flag) &&
95 (tr_ctx->draw_blocker & 4)) {
96 boolean block = FALSE;
97 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
98 (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
99 (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
100 (void *) tr_ctx->draw_rule.surf, 0,
101 (void *) tr_ctx->draw_rule.sampler_view, 0);
102 if (tr_ctx->draw_rule.fs &&
103 tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
105 if (tr_ctx->draw_rule.vs &&
106 tr_ctx->draw_rule.vs == tr_ctx->curr.vs)
108 if (tr_ctx->draw_rule.surf &&
109 tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf)
111 if (tr_ctx->draw_rule.surf)
112 for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
113 if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
115 if (tr_ctx->draw_rule.sampler_view) {
116 for (k = 0; k < tr_ctx->curr.num_sampler_views; k++)
117 if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.sampler_views[k])
119 for (k = 0; k < tr_ctx->curr.num_vert_sampler_views; k++) {
120 if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.vert_sampler_views[k]) {
127 tr_ctx->draw_blocked |= (flag | 4);
130 if (tr_ctx->draw_blocked)
131 trace_rbug_notify_draw_blocked(tr_ctx);
133 /* wait for rbug to clear the blocked flag */
134 while (tr_ctx->draw_blocked & flag) {
135 tr_ctx->draw_blocked |= flag;
136 #ifdef PIPE_THREAD_HAVE_CONDVAR
137 pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex);
139 pipe_mutex_unlock(tr_ctx->draw_mutex);
140 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
143 pipe_mutex_lock(tr_ctx->draw_mutex);
147 pipe_mutex_unlock(tr_ctx->draw_mutex);
151 trace_context_draw_arrays(struct pipe_context *_pipe,
152 unsigned mode, unsigned start, unsigned count)
154 struct trace_context *tr_ctx = trace_context(_pipe);
155 struct pipe_context *pipe = tr_ctx->pipe;
157 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
160 trace_context_draw_block(tr_ctx, 1);
162 trace_dump_call_begin("pipe_context", "draw_arrays");
164 trace_dump_arg(ptr, pipe);
165 trace_dump_arg(uint, mode);
166 trace_dump_arg(uint, start);
167 trace_dump_arg(uint, count);
169 pipe->draw_arrays(pipe, mode, start, count);
171 trace_dump_call_end();
173 trace_context_draw_block(tr_ctx, 2);
178 trace_context_draw_elements(struct pipe_context *_pipe,
179 struct pipe_resource *_indexBuffer,
180 unsigned indexSize, int indexBias,
181 unsigned mode, unsigned start, unsigned count)
183 struct trace_context *tr_ctx = trace_context(_pipe);
184 struct trace_resource *tr_buf = trace_resource(_indexBuffer);
185 struct pipe_context *pipe = tr_ctx->pipe;
186 struct pipe_resource *indexBuffer = tr_buf->resource;
188 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
191 trace_context_draw_block(tr_ctx, 1);
193 trace_dump_call_begin("pipe_context", "draw_elements");
195 trace_dump_arg(ptr, pipe);
196 trace_dump_arg(ptr, indexBuffer);
197 trace_dump_arg(uint, indexSize);
198 trace_dump_arg(int, indexBias);
199 trace_dump_arg(uint, mode);
200 trace_dump_arg(uint, start);
201 trace_dump_arg(uint, count);
203 pipe->draw_elements(pipe, indexBuffer, indexSize, indexBias,
206 trace_dump_call_end();
208 trace_context_draw_block(tr_ctx, 2);
213 trace_context_draw_range_elements(struct pipe_context *_pipe,
214 struct pipe_resource *_indexBuffer,
223 struct trace_context *tr_ctx = trace_context(_pipe);
224 struct trace_resource *tr_buf = trace_resource(_indexBuffer);
225 struct pipe_context *pipe = tr_ctx->pipe;
226 struct pipe_resource *indexBuffer = tr_buf->resource;
228 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
231 trace_context_draw_block(tr_ctx, 1);
233 trace_dump_call_begin("pipe_context", "draw_range_elements");
235 trace_dump_arg(ptr, pipe);
236 trace_dump_arg(ptr, indexBuffer);
237 trace_dump_arg(uint, indexSize);
238 trace_dump_arg(int, indexBias);
239 trace_dump_arg(uint, minIndex);
240 trace_dump_arg(uint, maxIndex);
241 trace_dump_arg(uint, mode);
242 trace_dump_arg(uint, start);
243 trace_dump_arg(uint, count);
245 pipe->draw_range_elements(pipe,
246 indexBuffer, indexSize, indexBias,
250 trace_dump_call_end();
252 trace_context_draw_block(tr_ctx, 2);
256 static INLINE struct pipe_query *
257 trace_context_create_query(struct pipe_context *_pipe,
260 struct trace_context *tr_ctx = trace_context(_pipe);
261 struct pipe_context *pipe = tr_ctx->pipe;
262 struct pipe_query *result;
264 trace_dump_call_begin("pipe_context", "create_query");
266 trace_dump_arg(ptr, pipe);
267 trace_dump_arg(uint, query_type);
269 result = pipe->create_query(pipe, query_type);
271 trace_dump_ret(ptr, result);
273 trace_dump_call_end();
280 trace_context_destroy_query(struct pipe_context *_pipe,
281 struct pipe_query *query)
283 struct trace_context *tr_ctx = trace_context(_pipe);
284 struct pipe_context *pipe = tr_ctx->pipe;
286 trace_dump_call_begin("pipe_context", "destroy_query");
288 trace_dump_arg(ptr, pipe);
289 trace_dump_arg(ptr, query);
291 pipe->destroy_query(pipe, query);
293 trace_dump_call_end();
298 trace_context_begin_query(struct pipe_context *_pipe,
299 struct pipe_query *query)
301 struct trace_context *tr_ctx = trace_context(_pipe);
302 struct pipe_context *pipe = tr_ctx->pipe;
304 trace_dump_call_begin("pipe_context", "begin_query");
306 trace_dump_arg(ptr, pipe);
307 trace_dump_arg(ptr, query);
309 pipe->begin_query(pipe, query);
311 trace_dump_call_end();
316 trace_context_end_query(struct pipe_context *_pipe,
317 struct pipe_query *query)
319 struct trace_context *tr_ctx = trace_context(_pipe);
320 struct pipe_context *pipe = tr_ctx->pipe;
322 trace_dump_call_begin("pipe_context", "end_query");
324 trace_dump_arg(ptr, pipe);
325 trace_dump_arg(ptr, query);
327 pipe->end_query(pipe, query);
329 trace_dump_call_end();
333 static INLINE boolean
334 trace_context_get_query_result(struct pipe_context *_pipe,
335 struct pipe_query *query,
339 struct trace_context *tr_ctx = trace_context(_pipe);
340 struct pipe_context *pipe = tr_ctx->pipe;
344 trace_dump_call_begin("pipe_context", "get_query_result");
346 trace_dump_arg(ptr, pipe);
348 _result = pipe->get_query_result(pipe, query, wait, presult);
351 trace_dump_arg(uint, result);
352 trace_dump_ret(bool, _result);
354 trace_dump_call_end();
361 trace_context_create_blend_state(struct pipe_context *_pipe,
362 const struct pipe_blend_state *state)
364 struct trace_context *tr_ctx = trace_context(_pipe);
365 struct pipe_context *pipe = tr_ctx->pipe;
368 trace_dump_call_begin("pipe_context", "create_blend_state");
370 trace_dump_arg(ptr, pipe);
371 trace_dump_arg(blend_state, state);
373 result = pipe->create_blend_state(pipe, state);
375 trace_dump_ret(ptr, result);
377 trace_dump_call_end();
384 trace_context_bind_blend_state(struct pipe_context *_pipe,
387 struct trace_context *tr_ctx = trace_context(_pipe);
388 struct pipe_context *pipe = tr_ctx->pipe;
390 trace_dump_call_begin("pipe_context", "bind_blend_state");
392 trace_dump_arg(ptr, pipe);
393 trace_dump_arg(ptr, state);
395 pipe->bind_blend_state(pipe, state);
397 trace_dump_call_end();
402 trace_context_delete_blend_state(struct pipe_context *_pipe,
405 struct trace_context *tr_ctx = trace_context(_pipe);
406 struct pipe_context *pipe = tr_ctx->pipe;
408 trace_dump_call_begin("pipe_context", "delete_blend_state");
410 trace_dump_arg(ptr, pipe);
411 trace_dump_arg(ptr, state);
413 pipe->delete_blend_state(pipe, state);
415 trace_dump_call_end();
420 trace_context_create_sampler_state(struct pipe_context *_pipe,
421 const struct pipe_sampler_state *state)
423 struct trace_context *tr_ctx = trace_context(_pipe);
424 struct pipe_context *pipe = tr_ctx->pipe;
427 trace_dump_call_begin("pipe_context", "create_sampler_state");
429 trace_dump_arg(ptr, pipe);
430 trace_dump_arg(sampler_state, state);
432 result = pipe->create_sampler_state(pipe, state);
434 trace_dump_ret(ptr, result);
436 trace_dump_call_end();
443 trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
447 struct trace_context *tr_ctx = trace_context(_pipe);
448 struct pipe_context *pipe = tr_ctx->pipe;
450 trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
452 trace_dump_arg(ptr, pipe);
453 trace_dump_arg(uint, num_states);
454 trace_dump_arg_array(ptr, states, num_states);
456 pipe->bind_fragment_sampler_states(pipe, num_states, states);
458 trace_dump_call_end();
463 trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
467 struct trace_context *tr_ctx = trace_context(_pipe);
468 struct pipe_context *pipe = tr_ctx->pipe;
470 trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
472 trace_dump_arg(ptr, pipe);
473 trace_dump_arg(uint, num_states);
474 trace_dump_arg_array(ptr, states, num_states);
476 pipe->bind_vertex_sampler_states(pipe, num_states, states);
478 trace_dump_call_end();
483 trace_context_delete_sampler_state(struct pipe_context *_pipe,
486 struct trace_context *tr_ctx = trace_context(_pipe);
487 struct pipe_context *pipe = tr_ctx->pipe;
489 trace_dump_call_begin("pipe_context", "delete_sampler_state");
491 trace_dump_arg(ptr, pipe);
492 trace_dump_arg(ptr, state);
494 pipe->delete_sampler_state(pipe, state);
496 trace_dump_call_end();
501 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
502 const struct pipe_rasterizer_state *state)
504 struct trace_context *tr_ctx = trace_context(_pipe);
505 struct pipe_context *pipe = tr_ctx->pipe;
508 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
510 trace_dump_arg(ptr, pipe);
511 trace_dump_arg(rasterizer_state, state);
513 result = pipe->create_rasterizer_state(pipe, state);
515 trace_dump_ret(ptr, result);
517 trace_dump_call_end();
524 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
527 struct trace_context *tr_ctx = trace_context(_pipe);
528 struct pipe_context *pipe = tr_ctx->pipe;
530 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
532 trace_dump_arg(ptr, pipe);
533 trace_dump_arg(ptr, state);
535 pipe->bind_rasterizer_state(pipe, state);
537 trace_dump_call_end();
542 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
545 struct trace_context *tr_ctx = trace_context(_pipe);
546 struct pipe_context *pipe = tr_ctx->pipe;
548 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
550 trace_dump_arg(ptr, pipe);
551 trace_dump_arg(ptr, state);
553 pipe->delete_rasterizer_state(pipe, state);
555 trace_dump_call_end();
560 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
561 const struct pipe_depth_stencil_alpha_state *state)
563 struct trace_context *tr_ctx = trace_context(_pipe);
564 struct pipe_context *pipe = tr_ctx->pipe;
567 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
569 result = pipe->create_depth_stencil_alpha_state(pipe, state);
571 trace_dump_arg(ptr, pipe);
572 trace_dump_arg(depth_stencil_alpha_state, state);
574 trace_dump_ret(ptr, result);
576 trace_dump_call_end();
583 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
586 struct trace_context *tr_ctx = trace_context(_pipe);
587 struct pipe_context *pipe = tr_ctx->pipe;
589 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
591 trace_dump_arg(ptr, pipe);
592 trace_dump_arg(ptr, state);
594 pipe->bind_depth_stencil_alpha_state(pipe, state);
596 trace_dump_call_end();
601 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
604 struct trace_context *tr_ctx = trace_context(_pipe);
605 struct pipe_context *pipe = tr_ctx->pipe;
607 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
609 trace_dump_arg(ptr, pipe);
610 trace_dump_arg(ptr, state);
612 pipe->delete_depth_stencil_alpha_state(pipe, state);
614 trace_dump_call_end();
619 trace_context_create_fs_state(struct pipe_context *_pipe,
620 const struct pipe_shader_state *state)
622 struct trace_context *tr_ctx = trace_context(_pipe);
623 struct pipe_context *pipe = tr_ctx->pipe;
626 trace_dump_call_begin("pipe_context", "create_fs_state");
628 trace_dump_arg(ptr, pipe);
629 trace_dump_arg(shader_state, state);
631 result = pipe->create_fs_state(pipe, state);
633 trace_dump_ret(ptr, result);
635 trace_dump_call_end();
637 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT);
644 trace_context_bind_fs_state(struct pipe_context *_pipe,
647 struct trace_context *tr_ctx = trace_context(_pipe);
648 struct trace_shader *tr_shdr = trace_shader(_state);
649 struct pipe_context *pipe = tr_ctx->pipe;
650 void *state = tr_shdr ? tr_shdr->state : NULL;
652 trace_dump_call_begin("pipe_context", "bind_fs_state");
654 trace_dump_arg(ptr, pipe);
655 trace_dump_arg(ptr, state);
657 tr_ctx->curr.fs = tr_shdr;
659 if (tr_shdr && tr_shdr->replaced)
660 state = tr_shdr->replaced;
662 pipe->bind_fs_state(pipe, state);
664 trace_dump_call_end();
669 trace_context_delete_fs_state(struct pipe_context *_pipe,
672 struct trace_context *tr_ctx = trace_context(_pipe);
673 struct trace_shader *tr_shdr = trace_shader(_state);
674 struct pipe_context *pipe = tr_ctx->pipe;
675 void *state = tr_shdr->state;
677 trace_dump_call_begin("pipe_context", "delete_fs_state");
679 trace_dump_arg(ptr, pipe);
680 trace_dump_arg(ptr, state);
682 pipe->delete_fs_state(pipe, state);
684 trace_dump_call_end();
686 trace_shader_destroy(tr_ctx, tr_shdr);
691 trace_context_create_vs_state(struct pipe_context *_pipe,
692 const struct pipe_shader_state *state)
694 struct trace_context *tr_ctx = trace_context(_pipe);
695 struct pipe_context *pipe = tr_ctx->pipe;
698 trace_dump_call_begin("pipe_context", "create_vs_state");
700 trace_dump_arg(ptr, pipe);
701 trace_dump_arg(shader_state, state);
703 result = pipe->create_vs_state(pipe, state);
705 trace_dump_ret(ptr, result);
707 trace_dump_call_end();
709 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX);
716 trace_context_bind_vs_state(struct pipe_context *_pipe,
719 struct trace_context *tr_ctx = trace_context(_pipe);
720 struct trace_shader *tr_shdr = trace_shader(_state);
721 struct pipe_context *pipe = tr_ctx->pipe;
722 void *state = tr_shdr ? tr_shdr->state : NULL;
724 trace_dump_call_begin("pipe_context", "bind_vs_state");
726 trace_dump_arg(ptr, pipe);
727 trace_dump_arg(ptr, state);
729 tr_ctx->curr.vs = tr_shdr;
731 if (tr_shdr && tr_shdr->replaced)
732 state = tr_shdr->replaced;
734 pipe->bind_vs_state(pipe, state);
736 trace_dump_call_end();
741 trace_context_delete_vs_state(struct pipe_context *_pipe,
744 struct trace_context *tr_ctx = trace_context(_pipe);
745 struct trace_shader *tr_shdr = trace_shader(_state);
746 struct pipe_context *pipe = tr_ctx->pipe;
747 void *state = tr_shdr->state;
749 trace_dump_call_begin("pipe_context", "delete_vs_state");
751 trace_dump_arg(ptr, pipe);
752 trace_dump_arg(ptr, state);
754 pipe->delete_vs_state(pipe, state);
756 trace_dump_call_end();
758 trace_shader_destroy(tr_ctx, tr_shdr);
763 trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
764 unsigned num_elements,
765 const struct pipe_vertex_element *elements)
767 struct trace_context *tr_ctx = trace_context(_pipe);
768 struct pipe_context *pipe = tr_ctx->pipe;
771 trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
773 trace_dump_arg(ptr, pipe);
774 trace_dump_arg(uint, num_elements);
776 trace_dump_arg_begin("elements");
777 trace_dump_struct_array(vertex_element, elements, num_elements);
778 trace_dump_arg_end();
780 result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
782 trace_dump_ret(ptr, result);
784 trace_dump_call_end();
791 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
794 struct trace_context *tr_ctx = trace_context(_pipe);
795 struct pipe_context *pipe = tr_ctx->pipe;
797 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
799 trace_dump_arg(ptr, pipe);
800 trace_dump_arg(ptr, state);
802 pipe->bind_vertex_elements_state(pipe, state);
804 trace_dump_call_end();
809 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
812 struct trace_context *tr_ctx = trace_context(_pipe);
813 struct pipe_context *pipe = tr_ctx->pipe;
815 trace_dump_call_begin("pipe_context", "delete_verte_elements_state");
817 trace_dump_arg(ptr, pipe);
818 trace_dump_arg(ptr, state);
820 pipe->delete_vertex_elements_state(pipe, state);
822 trace_dump_call_end();
827 trace_context_set_blend_color(struct pipe_context *_pipe,
828 const struct pipe_blend_color *state)
830 struct trace_context *tr_ctx = trace_context(_pipe);
831 struct pipe_context *pipe = tr_ctx->pipe;
833 trace_dump_call_begin("pipe_context", "set_blend_color");
835 trace_dump_arg(ptr, pipe);
836 trace_dump_arg(blend_color, state);
838 pipe->set_blend_color(pipe, state);
840 trace_dump_call_end();
845 trace_context_set_stencil_ref(struct pipe_context *_pipe,
846 const struct pipe_stencil_ref *state)
848 struct trace_context *tr_ctx = trace_context(_pipe);
849 struct pipe_context *pipe = tr_ctx->pipe;
851 trace_dump_call_begin("pipe_context", "set_stencil_ref");
853 trace_dump_arg(ptr, pipe);
854 trace_dump_arg(stencil_ref, state);
856 pipe->set_stencil_ref(pipe, state);
858 trace_dump_call_end();
863 trace_context_set_clip_state(struct pipe_context *_pipe,
864 const struct pipe_clip_state *state)
866 struct trace_context *tr_ctx = trace_context(_pipe);
867 struct pipe_context *pipe = tr_ctx->pipe;
869 trace_dump_call_begin("pipe_context", "set_clip_state");
871 trace_dump_arg(ptr, pipe);
872 trace_dump_arg(clip_state, state);
874 pipe->set_clip_state(pipe, state);
876 trace_dump_call_end();
881 trace_context_set_constant_buffer(struct pipe_context *_pipe,
882 uint shader, uint index,
883 struct pipe_resource *buffer)
885 struct trace_context *tr_ctx = trace_context(_pipe);
886 struct pipe_context *pipe = tr_ctx->pipe;
889 buffer = trace_resource_unwrap(tr_ctx, buffer);
892 trace_dump_call_begin("pipe_context", "set_constant_buffer");
894 trace_dump_arg(ptr, pipe);
895 trace_dump_arg(uint, shader);
896 trace_dump_arg(uint, index);
897 trace_dump_arg(ptr, buffer);
899 pipe->set_constant_buffer(pipe, shader, index, buffer);
901 trace_dump_call_end();
906 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
907 const struct pipe_framebuffer_state *state)
909 struct trace_context *tr_ctx = trace_context(_pipe);
910 struct pipe_context *pipe = tr_ctx->pipe;
911 struct pipe_framebuffer_state unwrapped_state;
915 tr_ctx->curr.nr_cbufs = state->nr_cbufs;
916 for (i = 0; i < state->nr_cbufs; i++)
918 tr_ctx->curr.cbufs[i] = trace_resource(state->cbufs[i]->texture);
920 tr_ctx->curr.cbufs[i] = NULL;
922 tr_ctx->curr.zsbuf = trace_resource(state->zsbuf->texture);
924 tr_ctx->curr.zsbuf = NULL;
927 /* Unwrap the input state */
928 memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
929 for(i = 0; i < state->nr_cbufs; ++i)
930 unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
931 for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
932 unwrapped_state.cbufs[i] = NULL;
933 unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
934 state = &unwrapped_state;
936 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
938 trace_dump_arg(ptr, pipe);
939 trace_dump_arg(framebuffer_state, state);
941 pipe->set_framebuffer_state(pipe, state);
943 trace_dump_call_end();
948 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
949 const struct pipe_poly_stipple *state)
951 struct trace_context *tr_ctx = trace_context(_pipe);
952 struct pipe_context *pipe = tr_ctx->pipe;
954 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
956 trace_dump_arg(ptr, pipe);
957 trace_dump_arg(poly_stipple, state);
959 pipe->set_polygon_stipple(pipe, state);
961 trace_dump_call_end();
966 trace_context_set_scissor_state(struct pipe_context *_pipe,
967 const struct pipe_scissor_state *state)
969 struct trace_context *tr_ctx = trace_context(_pipe);
970 struct pipe_context *pipe = tr_ctx->pipe;
972 trace_dump_call_begin("pipe_context", "set_scissor_state");
974 trace_dump_arg(ptr, pipe);
975 trace_dump_arg(scissor_state, state);
977 pipe->set_scissor_state(pipe, state);
979 trace_dump_call_end();
984 trace_context_set_viewport_state(struct pipe_context *_pipe,
985 const struct pipe_viewport_state *state)
987 struct trace_context *tr_ctx = trace_context(_pipe);
988 struct pipe_context *pipe = tr_ctx->pipe;
990 trace_dump_call_begin("pipe_context", "set_viewport_state");
992 trace_dump_arg(ptr, pipe);
993 trace_dump_arg(viewport_state, state);
995 pipe->set_viewport_state(pipe, state);
997 trace_dump_call_end();
1001 static struct pipe_sampler_view *
1002 trace_create_sampler_view(struct pipe_context *_pipe,
1003 struct pipe_resource *_resource,
1004 const struct pipe_sampler_view *templ)
1006 struct trace_context *tr_ctx = trace_context(_pipe);
1007 struct trace_resource *tr_tex = trace_resource(_resource);
1008 struct pipe_context *pipe = tr_ctx->pipe;
1009 struct pipe_resource *texture = tr_tex->resource;
1010 struct pipe_sampler_view *result;
1011 struct trace_sampler_view *tr_view;
1013 trace_dump_call_begin("pipe_context", "create_sampler_view");
1015 trace_dump_arg(ptr, pipe);
1016 trace_dump_arg(ptr, texture);
1017 trace_dump_arg(sampler_view_template, templ);
1019 result = pipe->create_sampler_view(pipe, texture, templ);
1021 trace_dump_ret(ptr, result);
1023 trace_dump_call_end();
1026 * Wrap pipe_sampler_view
1028 tr_view = CALLOC_STRUCT(trace_sampler_view);
1029 tr_view->base = *templ;
1030 tr_view->base.reference.count = 1;
1031 tr_view->base.texture = NULL;
1032 pipe_resource_reference(&tr_view->base.texture, _resource);
1033 tr_view->base.context = _pipe;
1034 tr_view->sampler_view = result;
1035 result = &tr_view->base;
1042 trace_sampler_view_destroy(struct pipe_context *_pipe,
1043 struct pipe_sampler_view *_view)
1045 struct trace_context *tr_ctx = trace_context(_pipe);
1046 struct trace_sampler_view *tr_view = trace_sampler_view(_view);
1047 struct pipe_context *pipe = tr_ctx->pipe;
1048 struct pipe_sampler_view *view = tr_view->sampler_view;
1050 trace_dump_call_begin("pipe_context", "sampler_view_destroy");
1052 trace_dump_arg(ptr, pipe);
1053 trace_dump_arg(ptr, view);
1055 pipe->sampler_view_destroy(pipe, view);
1057 trace_dump_call_end();
1059 pipe_resource_reference(&_view->texture, NULL);
1065 trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
1067 struct pipe_sampler_view **views)
1069 struct trace_context *tr_ctx = trace_context(_pipe);
1070 struct trace_sampler_view *tr_view;
1071 struct pipe_context *pipe = tr_ctx->pipe;
1072 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
1075 tr_ctx->curr.num_sampler_views = num;
1076 for(i = 0; i < num; ++i) {
1077 tr_view = trace_sampler_view(views[i]);
1078 tr_ctx->curr.sampler_views[i] = tr_view;
1079 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1081 views = unwrapped_views;
1083 trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
1085 trace_dump_arg(ptr, pipe);
1086 trace_dump_arg(uint, num);
1087 trace_dump_arg_array(ptr, views, num);
1089 pipe->set_fragment_sampler_views(pipe, num, views);
1091 trace_dump_call_end();
1096 trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
1098 struct pipe_sampler_view **views)
1100 struct trace_context *tr_ctx = trace_context(_pipe);
1101 struct trace_sampler_view *tr_view;
1102 struct pipe_context *pipe = tr_ctx->pipe;
1103 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
1106 tr_ctx->curr.num_vert_sampler_views = num;
1107 for(i = 0; i < num; ++i) {
1108 tr_view = trace_sampler_view(views[i]);
1109 tr_ctx->curr.vert_sampler_views[i] = tr_view;
1110 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1112 views = unwrapped_views;
1114 trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
1116 trace_dump_arg(ptr, pipe);
1117 trace_dump_arg(uint, num);
1118 trace_dump_arg_array(ptr, views, num);
1120 pipe->set_vertex_sampler_views(pipe, num, views);
1122 trace_dump_call_end();
1127 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1128 unsigned num_buffers,
1129 const struct pipe_vertex_buffer *buffers)
1131 struct trace_context *tr_ctx = trace_context(_pipe);
1132 struct pipe_context *pipe = tr_ctx->pipe;
1135 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1137 trace_dump_arg(ptr, pipe);
1138 trace_dump_arg(uint, num_buffers);
1140 trace_dump_arg_begin("buffers");
1141 trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1142 trace_dump_arg_end();
1145 struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
1146 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1147 for (i = 0; i < num_buffers; i++)
1148 _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
1149 pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1152 pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1155 trace_dump_call_end();
1160 trace_context_surface_copy(struct pipe_context *_pipe,
1161 struct pipe_surface *dest,
1162 unsigned destx, unsigned desty,
1163 struct pipe_surface *src,
1164 unsigned srcx, unsigned srcy,
1165 unsigned width, unsigned height)
1167 struct trace_context *tr_ctx = trace_context(_pipe);
1168 struct pipe_context *pipe = tr_ctx->pipe;
1170 dest = trace_surface_unwrap(tr_ctx, dest);
1171 src = trace_surface_unwrap(tr_ctx, src);
1173 trace_dump_call_begin("pipe_context", "surface_copy");
1175 trace_dump_arg(ptr, pipe);
1176 trace_dump_arg(ptr, dest);
1177 trace_dump_arg(uint, destx);
1178 trace_dump_arg(uint, desty);
1179 trace_dump_arg(ptr, src);
1180 trace_dump_arg(uint, srcx);
1181 trace_dump_arg(uint, srcy);
1182 trace_dump_arg(uint, width);
1183 trace_dump_arg(uint, height);
1185 pipe->surface_copy(pipe,
1187 src, srcx, srcy, width, height);
1189 trace_dump_call_end();
1194 trace_context_surface_fill(struct pipe_context *_pipe,
1195 struct pipe_surface *dst,
1196 unsigned dstx, unsigned dsty,
1197 unsigned width, unsigned height,
1200 struct trace_context *tr_ctx = trace_context(_pipe);
1201 struct pipe_context *pipe = tr_ctx->pipe;
1203 dst = trace_surface_unwrap(tr_ctx, dst);
1205 trace_dump_call_begin("pipe_context", "surface_fill");
1207 trace_dump_arg(ptr, pipe);
1208 trace_dump_arg(ptr, dst);
1209 trace_dump_arg(uint, dstx);
1210 trace_dump_arg(uint, dsty);
1211 trace_dump_arg(uint, width);
1212 trace_dump_arg(uint, height);
1214 pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);
1216 trace_dump_call_end();
1221 trace_context_clear(struct pipe_context *_pipe,
1227 struct trace_context *tr_ctx = trace_context(_pipe);
1228 struct pipe_context *pipe = tr_ctx->pipe;
1230 trace_dump_call_begin("pipe_context", "clear");
1232 trace_dump_arg(ptr, pipe);
1233 trace_dump_arg(uint, buffers);
1234 trace_dump_arg_array(float, rgba, 4);
1235 trace_dump_arg(float, depth);
1236 trace_dump_arg(uint, stencil);
1238 pipe->clear(pipe, buffers, rgba, depth, stencil);
1240 trace_dump_call_end();
1245 trace_context_flush(struct pipe_context *_pipe,
1247 struct pipe_fence_handle **fence)
1249 struct trace_context *tr_ctx = trace_context(_pipe);
1250 struct pipe_context *pipe = tr_ctx->pipe;
1252 trace_dump_call_begin("pipe_context", "flush");
1254 trace_dump_arg(ptr, pipe);
1255 trace_dump_arg(uint, flags);
1257 pipe->flush(pipe, flags, fence);
1260 trace_dump_ret(ptr, *fence);
1262 trace_dump_call_end();
1267 trace_context_destroy(struct pipe_context *_pipe)
1269 struct trace_screen *tr_scr = trace_screen(_pipe->screen);
1270 struct trace_context *tr_ctx = trace_context(_pipe);
1271 struct pipe_context *pipe = tr_ctx->pipe;
1273 trace_dump_call_begin("pipe_context", "destroy");
1274 trace_dump_arg(ptr, pipe);
1275 trace_dump_call_end();
1277 trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
1279 pipe->destroy(pipe);
1285 trace_is_resource_referenced( struct pipe_context *_pipe,
1286 struct pipe_resource *_resource,
1287 unsigned face, unsigned level)
1289 struct trace_context *tr_ctx = trace_context(_pipe);
1290 struct trace_resource *tr_tex = trace_resource(_resource);
1291 struct pipe_context *pipe = tr_ctx->pipe;
1292 struct pipe_resource *texture = tr_tex->resource;
1293 unsigned int referenced;
1295 trace_dump_call_begin("pipe_context", "is_resource_referenced");
1296 trace_dump_arg(ptr, pipe);
1297 trace_dump_arg(ptr, texture);
1298 trace_dump_arg(uint, face);
1299 trace_dump_arg(uint, level);
1301 referenced = pipe->is_resource_referenced(pipe, texture, face, level);
1303 trace_dump_ret(uint, referenced);
1304 trace_dump_call_end();
1310 /********************************************************************
1315 static struct pipe_transfer *
1316 trace_context_get_transfer(struct pipe_context *_context,
1317 struct pipe_resource *_resource,
1318 struct pipe_subresource sr,
1320 const struct pipe_box *box)
1322 struct trace_context *tr_context = trace_context(_context);
1323 struct trace_resource *tr_tex = trace_resource(_resource);
1324 struct pipe_context *context = tr_context->pipe;
1325 struct pipe_resource *texture = tr_tex->resource;
1326 struct pipe_transfer *result = NULL;
1328 assert(texture->screen == context->screen);
1331 * Map and transfers can't be serialized so we convert all write transfers
1332 * to transfer_inline_write and ignore read transfers.
1335 result = context->get_transfer(context, texture, sr, usage, box);
1338 result = trace_transfer_create(tr_context, tr_tex, result);
1345 trace_context_transfer_destroy(struct pipe_context *_context,
1346 struct pipe_transfer *_transfer)
1348 struct trace_context *tr_context = trace_context(_context);
1349 struct trace_transfer *tr_trans = trace_transfer(_transfer);
1351 trace_transfer_destroy(tr_context, tr_trans);
1356 trace_context_transfer_map(struct pipe_context *_context,
1357 struct pipe_transfer *_transfer)
1359 struct trace_context *tr_context = trace_context(_context);
1360 struct trace_transfer *tr_trans = trace_transfer(_transfer);
1361 struct pipe_context *context = tr_context->pipe;
1362 struct pipe_transfer *transfer = tr_trans->transfer;
1365 map = context->transfer_map(context, transfer);
1367 if(transfer->usage & PIPE_TRANSFER_WRITE) {
1368 assert(!tr_trans->map);
1369 tr_trans->map = map;
1378 trace_context_transfer_flush_region( struct pipe_context *_context,
1379 struct pipe_transfer *_transfer,
1380 const struct pipe_box *box)
1382 struct trace_context *tr_context = trace_context(_context);
1383 struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1384 struct pipe_context *context = tr_context->pipe;
1385 struct pipe_transfer *transfer = tr_transfer->transfer;
1387 context->transfer_flush_region(context,
1393 trace_context_transfer_unmap(struct pipe_context *_context,
1394 struct pipe_transfer *_transfer)
1396 struct trace_context *tr_ctx = trace_context(_context);
1397 struct trace_transfer *tr_trans = trace_transfer(_transfer);
1398 struct pipe_context *context = tr_ctx->pipe;
1399 struct pipe_transfer *transfer = tr_trans->transfer;
1403 * Fake a transfer_inline_write
1406 struct pipe_resource *resource = transfer->resource;
1407 struct pipe_subresource sr = transfer->sr;
1408 unsigned usage = transfer->usage;
1409 const struct pipe_box *box = &transfer->box;
1410 unsigned stride = transfer->stride;
1411 unsigned slice_stride = transfer->slice_stride;
1413 trace_dump_call_begin("pipe_context", "transfer_inline_write");
1415 trace_dump_arg(ptr, context);
1416 trace_dump_arg(ptr, resource);
1417 trace_dump_arg_struct(subresource, sr);
1418 trace_dump_arg(uint, usage);
1419 trace_dump_arg(box, box);
1421 trace_dump_arg_begin("data");
1422 trace_dump_box_bytes(tr_trans->map,
1427 trace_dump_arg_end();
1429 trace_dump_arg(uint, stride);
1430 trace_dump_arg(uint, slice_stride);
1432 trace_dump_call_end();
1434 tr_trans->map = NULL;
1437 context->transfer_unmap(context, transfer);
1442 trace_context_transfer_inline_write(struct pipe_context *_context,
1443 struct pipe_resource *_resource,
1444 struct pipe_subresource sr,
1446 const struct pipe_box *box,
1449 unsigned slice_stride)
1451 struct trace_context *tr_context = trace_context(_context);
1452 struct trace_resource *tr_tex = trace_resource(_resource);
1453 struct pipe_context *context = tr_context->pipe;
1454 struct pipe_resource *resource = tr_tex->resource;
1456 assert(resource->screen == context->screen);
1458 trace_dump_call_begin("pipe_context", "transfer_inline_write");
1460 trace_dump_arg(ptr, context);
1461 trace_dump_arg(ptr, resource);
1462 trace_dump_arg_struct(subresource, sr);
1463 trace_dump_arg(uint, usage);
1464 trace_dump_arg(box, box);
1466 trace_dump_arg_begin("data");
1467 trace_dump_box_bytes(data,
1472 trace_dump_arg_end();
1474 trace_dump_arg(uint, stride);
1475 trace_dump_arg(uint, slice_stride);
1477 trace_dump_call_end();
1479 context->transfer_inline_write(context, resource,
1480 sr, usage, box, data, stride, slice_stride);
1486 static const struct debug_named_value rbug_blocker_flags[] = {
1492 struct pipe_context *
1493 trace_context_create(struct trace_screen *tr_scr,
1494 struct pipe_context *pipe)
1496 struct trace_context *tr_ctx;
1501 if(!trace_enabled())
1504 tr_ctx = CALLOC_STRUCT(trace_context);
1508 tr_ctx->base.winsys = NULL;
1509 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1510 tr_ctx->base.screen = &tr_scr->base;
1511 tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
1514 pipe_mutex_init(tr_ctx->draw_mutex);
1515 pipe_condvar_init(tr_ctx->draw_cond);
1516 pipe_mutex_init(tr_ctx->list_mutex);
1517 make_empty_list(&tr_ctx->shaders);
1519 tr_ctx->base.destroy = trace_context_destroy;
1520 tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1521 tr_ctx->base.draw_elements = trace_context_draw_elements;
1522 tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1523 tr_ctx->base.create_query = trace_context_create_query;
1524 tr_ctx->base.destroy_query = trace_context_destroy_query;
1525 tr_ctx->base.begin_query = trace_context_begin_query;
1526 tr_ctx->base.end_query = trace_context_end_query;
1527 tr_ctx->base.get_query_result = trace_context_get_query_result;
1528 tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1529 tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1530 tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1531 tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1532 tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1533 tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1534 tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1535 tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1536 tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1537 tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1538 tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1539 tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1540 tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1541 tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1542 tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1543 tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1544 tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1545 tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1546 tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1547 tr_ctx->base.create_vertex_elements_state = trace_context_create_vertex_elements_state;
1548 tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state;
1549 tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state;
1550 tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1551 tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
1552 tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1553 tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1554 tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1555 tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1556 tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1557 tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1558 tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
1559 tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
1560 tr_ctx->base.create_sampler_view = trace_create_sampler_view;
1561 tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy;
1562 tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1563 if (pipe->surface_copy)
1564 tr_ctx->base.surface_copy = trace_context_surface_copy;
1565 if (pipe->surface_fill)
1566 tr_ctx->base.surface_fill = trace_context_surface_fill;
1567 tr_ctx->base.clear = trace_context_clear;
1568 tr_ctx->base.flush = trace_context_flush;
1569 tr_ctx->base.is_resource_referenced = trace_is_resource_referenced;
1571 tr_ctx->base.get_transfer = trace_context_get_transfer;
1572 tr_ctx->base.transfer_destroy = trace_context_transfer_destroy;
1573 tr_ctx->base.transfer_map = trace_context_transfer_map;
1574 tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
1575 tr_ctx->base.transfer_flush_region = trace_context_transfer_flush_region;
1576 tr_ctx->base.transfer_inline_write = trace_context_transfer_inline_write;
1578 tr_ctx->pipe = pipe;
1580 trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
1582 return &tr_ctx->base;