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_memory.h"
29 #include "util/u_simple_list.h"
31 #include "pipe/p_screen.h"
34 #include "tr_dump_state.h"
36 #include "tr_buffer.h"
37 #include "tr_screen.h"
38 #include "tr_texture.h"
41 static INLINE struct pipe_buffer *
42 trace_buffer_unwrap(struct trace_context *tr_ctx,
43 struct pipe_buffer *buffer)
45 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
46 struct trace_buffer *tr_buf;
51 tr_buf = trace_buffer(buffer);
53 assert(tr_buf->buffer);
54 assert(tr_buf->buffer->screen == tr_scr->screen);
55 return tr_buf->buffer;
59 static INLINE struct pipe_texture *
60 trace_texture_unwrap(struct trace_context *tr_ctx,
61 struct pipe_texture *texture)
63 struct trace_texture *tr_tex;
68 tr_tex = trace_texture(texture);
70 assert(tr_tex->texture);
71 return tr_tex->texture;
75 static INLINE struct pipe_surface *
76 trace_surface_unwrap(struct trace_context *tr_ctx,
77 struct pipe_surface *surface)
79 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
80 struct trace_surface *tr_surf;
85 assert(surface->texture);
89 tr_surf = trace_surface(surface);
91 assert(tr_surf->surface);
92 assert(tr_surf->surface->texture->screen == tr_scr->screen);
93 return tr_surf->surface;
98 trace_context_set_edgeflags(struct pipe_context *_pipe,
99 const unsigned *bitfield)
101 struct trace_context *tr_ctx = trace_context(_pipe);
102 struct pipe_context *pipe = tr_ctx->pipe;
104 trace_dump_call_begin("pipe_context", "set_edgeflags");
106 trace_dump_arg(ptr, pipe);
107 /* FIXME: we don't know how big this array is */
108 trace_dump_arg(ptr, bitfield);
110 pipe->set_edgeflags(pipe, bitfield);
112 trace_dump_call_end();
117 trace_context_draw_block(struct trace_context *tr_ctx, int flag)
121 pipe_mutex_lock(tr_ctx->draw_mutex);
123 if (tr_ctx->draw_blocker & flag) {
124 tr_ctx->draw_blocked |= flag;
125 } else if ((tr_ctx->draw_rule.blocker & flag) &&
126 (tr_ctx->draw_blocker & 4)) {
127 boolean block = FALSE;
128 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
129 (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
130 (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
131 (void *) tr_ctx->draw_rule.surf, 0,
132 (void *) tr_ctx->draw_rule.tex, 0);
133 if (tr_ctx->draw_rule.fs &&
134 tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
136 if (tr_ctx->draw_rule.vs &&
137 tr_ctx->draw_rule.vs == tr_ctx->curr.vs)
139 if (tr_ctx->draw_rule.surf &&
140 tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf)
142 if (tr_ctx->draw_rule.surf)
143 for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
144 if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
146 if (tr_ctx->draw_rule.tex) {
147 for (k = 0; k < tr_ctx->curr.num_texs; k++)
148 if (tr_ctx->draw_rule.tex == tr_ctx->curr.tex[k])
150 for (k = 0; k < tr_ctx->curr.num_vert_texs; k++) {
151 if (tr_ctx->draw_rule.tex == tr_ctx->curr.vert_tex[k]) {
158 tr_ctx->draw_blocked |= (flag | 4);
161 if (tr_ctx->draw_blocked)
162 trace_rbug_notify_draw_blocked(tr_ctx);
164 /* wait for rbug to clear the blocked flag */
165 while (tr_ctx->draw_blocked & flag) {
166 tr_ctx->draw_blocked |= flag;
167 #ifdef PIPE_THREAD_HAVE_CONDVAR
168 pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex);
170 pipe_mutex_unlock(tr_ctx->draw_mutex);
171 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
174 pipe_mutex_lock(tr_ctx->draw_mutex);
178 pipe_mutex_unlock(tr_ctx->draw_mutex);
181 static INLINE boolean
182 trace_context_draw_arrays(struct pipe_context *_pipe,
183 unsigned mode, unsigned start, unsigned count)
185 struct trace_context *tr_ctx = trace_context(_pipe);
186 struct pipe_context *pipe = tr_ctx->pipe;
189 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
192 trace_context_draw_block(tr_ctx, 1);
194 trace_dump_call_begin("pipe_context", "draw_arrays");
196 trace_dump_arg(ptr, pipe);
197 trace_dump_arg(uint, mode);
198 trace_dump_arg(uint, start);
199 trace_dump_arg(uint, count);
201 result = pipe->draw_arrays(pipe, mode, start, count);
203 trace_dump_ret(bool, result);
205 trace_dump_call_end();
207 trace_context_draw_block(tr_ctx, 2);
213 static INLINE boolean
214 trace_context_draw_elements(struct pipe_context *_pipe,
215 struct pipe_buffer *_indexBuffer,
217 unsigned mode, unsigned start, unsigned count)
219 struct trace_context *tr_ctx = trace_context(_pipe);
220 struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
221 struct pipe_context *pipe = tr_ctx->pipe;
222 struct pipe_buffer *indexBuffer = tr_buf->buffer;
225 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
228 trace_context_draw_block(tr_ctx, 1);
230 trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
232 trace_dump_call_begin("pipe_context", "draw_elements");
234 trace_dump_arg(ptr, pipe);
235 trace_dump_arg(ptr, indexBuffer);
236 trace_dump_arg(uint, indexSize);
237 trace_dump_arg(uint, mode);
238 trace_dump_arg(uint, start);
239 trace_dump_arg(uint, count);
241 result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);
243 trace_dump_ret(bool, result);
245 trace_dump_call_end();
247 trace_context_draw_block(tr_ctx, 2);
253 static INLINE boolean
254 trace_context_draw_range_elements(struct pipe_context *_pipe,
255 struct pipe_buffer *_indexBuffer,
263 struct trace_context *tr_ctx = trace_context(_pipe);
264 struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
265 struct pipe_context *pipe = tr_ctx->pipe;
266 struct pipe_buffer *indexBuffer = tr_buf->buffer;
269 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
272 trace_context_draw_block(tr_ctx, 1);
274 trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
276 trace_dump_call_begin("pipe_context", "draw_range_elements");
278 trace_dump_arg(ptr, pipe);
279 trace_dump_arg(ptr, indexBuffer);
280 trace_dump_arg(uint, indexSize);
281 trace_dump_arg(uint, minIndex);
282 trace_dump_arg(uint, maxIndex);
283 trace_dump_arg(uint, mode);
284 trace_dump_arg(uint, start);
285 trace_dump_arg(uint, count);
287 result = pipe->draw_range_elements(pipe,
289 indexSize, minIndex, maxIndex,
292 trace_dump_ret(bool, result);
294 trace_dump_call_end();
296 trace_context_draw_block(tr_ctx, 2);
302 static INLINE struct pipe_query *
303 trace_context_create_query(struct pipe_context *_pipe,
306 struct trace_context *tr_ctx = trace_context(_pipe);
307 struct pipe_context *pipe = tr_ctx->pipe;
308 struct pipe_query *result;
310 trace_dump_call_begin("pipe_context", "create_query");
312 trace_dump_arg(ptr, pipe);
313 trace_dump_arg(uint, query_type);
315 result = pipe->create_query(pipe, query_type);
317 trace_dump_ret(ptr, result);
319 trace_dump_call_end();
326 trace_context_destroy_query(struct pipe_context *_pipe,
327 struct pipe_query *query)
329 struct trace_context *tr_ctx = trace_context(_pipe);
330 struct pipe_context *pipe = tr_ctx->pipe;
332 trace_dump_call_begin("pipe_context", "destroy_query");
334 trace_dump_arg(ptr, pipe);
335 trace_dump_arg(ptr, query);
337 pipe->destroy_query(pipe, query);
339 trace_dump_call_end();
344 trace_context_begin_query(struct pipe_context *_pipe,
345 struct pipe_query *query)
347 struct trace_context *tr_ctx = trace_context(_pipe);
348 struct pipe_context *pipe = tr_ctx->pipe;
350 trace_dump_call_begin("pipe_context", "begin_query");
352 trace_dump_arg(ptr, pipe);
353 trace_dump_arg(ptr, query);
355 pipe->begin_query(pipe, query);
357 trace_dump_call_end();
362 trace_context_end_query(struct pipe_context *_pipe,
363 struct pipe_query *query)
365 struct trace_context *tr_ctx = trace_context(_pipe);
366 struct pipe_context *pipe = tr_ctx->pipe;
368 trace_dump_call_begin("pipe_context", "end_query");
370 trace_dump_arg(ptr, pipe);
371 trace_dump_arg(ptr, query);
373 pipe->end_query(pipe, query);
375 trace_dump_call_end();
379 static INLINE boolean
380 trace_context_get_query_result(struct pipe_context *_pipe,
381 struct pipe_query *query,
385 struct trace_context *tr_ctx = trace_context(_pipe);
386 struct pipe_context *pipe = tr_ctx->pipe;
390 trace_dump_call_begin("pipe_context", "get_query_result");
392 trace_dump_arg(ptr, pipe);
394 _result = pipe->get_query_result(pipe, query, wait, presult);
397 trace_dump_arg(uint, result);
398 trace_dump_ret(bool, _result);
400 trace_dump_call_end();
407 trace_context_create_blend_state(struct pipe_context *_pipe,
408 const struct pipe_blend_state *state)
410 struct trace_context *tr_ctx = trace_context(_pipe);
411 struct pipe_context *pipe = tr_ctx->pipe;
414 trace_dump_call_begin("pipe_context", "create_blend_state");
416 trace_dump_arg(ptr, pipe);
417 trace_dump_arg(blend_state, state);
419 result = pipe->create_blend_state(pipe, state);
421 trace_dump_ret(ptr, result);
423 trace_dump_call_end();
430 trace_context_bind_blend_state(struct pipe_context *_pipe,
433 struct trace_context *tr_ctx = trace_context(_pipe);
434 struct pipe_context *pipe = tr_ctx->pipe;
436 trace_dump_call_begin("pipe_context", "bind_blend_state");
438 trace_dump_arg(ptr, pipe);
439 trace_dump_arg(ptr, state);
441 pipe->bind_blend_state(pipe, state);
443 trace_dump_call_end();
448 trace_context_delete_blend_state(struct pipe_context *_pipe,
451 struct trace_context *tr_ctx = trace_context(_pipe);
452 struct pipe_context *pipe = tr_ctx->pipe;
454 trace_dump_call_begin("pipe_context", "delete_blend_state");
456 trace_dump_arg(ptr, pipe);
457 trace_dump_arg(ptr, state);
459 pipe->delete_blend_state(pipe, state);
461 trace_dump_call_end();
466 trace_context_create_sampler_state(struct pipe_context *_pipe,
467 const struct pipe_sampler_state *state)
469 struct trace_context *tr_ctx = trace_context(_pipe);
470 struct pipe_context *pipe = tr_ctx->pipe;
473 trace_dump_call_begin("pipe_context", "create_sampler_state");
475 trace_dump_arg(ptr, pipe);
476 trace_dump_arg(sampler_state, state);
478 result = pipe->create_sampler_state(pipe, state);
480 trace_dump_ret(ptr, result);
482 trace_dump_call_end();
489 trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
493 struct trace_context *tr_ctx = trace_context(_pipe);
494 struct pipe_context *pipe = tr_ctx->pipe;
496 trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
498 trace_dump_arg(ptr, pipe);
499 trace_dump_arg(uint, num_states);
500 trace_dump_arg_array(ptr, states, num_states);
502 pipe->bind_fragment_sampler_states(pipe, num_states, states);
504 trace_dump_call_end();
509 trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
513 struct trace_context *tr_ctx = trace_context(_pipe);
514 struct pipe_context *pipe = tr_ctx->pipe;
516 trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
518 trace_dump_arg(ptr, pipe);
519 trace_dump_arg(uint, num_states);
520 trace_dump_arg_array(ptr, states, num_states);
522 pipe->bind_vertex_sampler_states(pipe, num_states, states);
524 trace_dump_call_end();
529 trace_context_delete_sampler_state(struct pipe_context *_pipe,
532 struct trace_context *tr_ctx = trace_context(_pipe);
533 struct pipe_context *pipe = tr_ctx->pipe;
535 trace_dump_call_begin("pipe_context", "delete_sampler_state");
537 trace_dump_arg(ptr, pipe);
538 trace_dump_arg(ptr, state);
540 pipe->delete_sampler_state(pipe, state);
542 trace_dump_call_end();
547 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
548 const struct pipe_rasterizer_state *state)
550 struct trace_context *tr_ctx = trace_context(_pipe);
551 struct pipe_context *pipe = tr_ctx->pipe;
554 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
556 trace_dump_arg(ptr, pipe);
557 trace_dump_arg(rasterizer_state, state);
559 result = pipe->create_rasterizer_state(pipe, state);
561 trace_dump_ret(ptr, result);
563 trace_dump_call_end();
570 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
573 struct trace_context *tr_ctx = trace_context(_pipe);
574 struct pipe_context *pipe = tr_ctx->pipe;
576 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
578 trace_dump_arg(ptr, pipe);
579 trace_dump_arg(ptr, state);
581 pipe->bind_rasterizer_state(pipe, state);
583 trace_dump_call_end();
588 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
591 struct trace_context *tr_ctx = trace_context(_pipe);
592 struct pipe_context *pipe = tr_ctx->pipe;
594 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
596 trace_dump_arg(ptr, pipe);
597 trace_dump_arg(ptr, state);
599 pipe->delete_rasterizer_state(pipe, state);
601 trace_dump_call_end();
606 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
607 const struct pipe_depth_stencil_alpha_state *state)
609 struct trace_context *tr_ctx = trace_context(_pipe);
610 struct pipe_context *pipe = tr_ctx->pipe;
613 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
615 result = pipe->create_depth_stencil_alpha_state(pipe, state);
617 trace_dump_arg(ptr, pipe);
618 trace_dump_arg(depth_stencil_alpha_state, state);
620 trace_dump_ret(ptr, result);
622 trace_dump_call_end();
629 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
632 struct trace_context *tr_ctx = trace_context(_pipe);
633 struct pipe_context *pipe = tr_ctx->pipe;
635 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
637 trace_dump_arg(ptr, pipe);
638 trace_dump_arg(ptr, state);
640 pipe->bind_depth_stencil_alpha_state(pipe, state);
642 trace_dump_call_end();
647 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
650 struct trace_context *tr_ctx = trace_context(_pipe);
651 struct pipe_context *pipe = tr_ctx->pipe;
653 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
655 trace_dump_arg(ptr, pipe);
656 trace_dump_arg(ptr, state);
658 pipe->delete_depth_stencil_alpha_state(pipe, state);
660 trace_dump_call_end();
665 trace_context_create_fs_state(struct pipe_context *_pipe,
666 const struct pipe_shader_state *state)
668 struct trace_context *tr_ctx = trace_context(_pipe);
669 struct pipe_context *pipe = tr_ctx->pipe;
672 trace_dump_call_begin("pipe_context", "create_fs_state");
674 trace_dump_arg(ptr, pipe);
675 trace_dump_arg(shader_state, state);
677 result = pipe->create_fs_state(pipe, state);
679 trace_dump_ret(ptr, result);
681 trace_dump_call_end();
683 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT);
690 trace_context_bind_fs_state(struct pipe_context *_pipe,
693 struct trace_context *tr_ctx = trace_context(_pipe);
694 struct trace_shader *tr_shdr = trace_shader(_state);
695 struct pipe_context *pipe = tr_ctx->pipe;
696 void *state = tr_shdr ? tr_shdr->state : NULL;
698 trace_dump_call_begin("pipe_context", "bind_fs_state");
700 trace_dump_arg(ptr, pipe);
701 trace_dump_arg(ptr, state);
703 tr_ctx->curr.fs = tr_shdr;
705 if (tr_shdr && tr_shdr->replaced)
706 state = tr_shdr->replaced;
708 pipe->bind_fs_state(pipe, state);
710 trace_dump_call_end();
715 trace_context_delete_fs_state(struct pipe_context *_pipe,
718 struct trace_context *tr_ctx = trace_context(_pipe);
719 struct trace_shader *tr_shdr = trace_shader(_state);
720 struct pipe_context *pipe = tr_ctx->pipe;
721 void *state = tr_shdr->state;
723 trace_dump_call_begin("pipe_context", "delete_fs_state");
725 trace_dump_arg(ptr, pipe);
726 trace_dump_arg(ptr, state);
728 pipe->delete_fs_state(pipe, state);
730 trace_dump_call_end();
732 trace_shader_destroy(tr_ctx, tr_shdr);
737 trace_context_create_vs_state(struct pipe_context *_pipe,
738 const struct pipe_shader_state *state)
740 struct trace_context *tr_ctx = trace_context(_pipe);
741 struct pipe_context *pipe = tr_ctx->pipe;
744 trace_dump_call_begin("pipe_context", "create_vs_state");
746 trace_dump_arg(ptr, pipe);
747 trace_dump_arg(shader_state, state);
749 result = pipe->create_vs_state(pipe, state);
751 trace_dump_ret(ptr, result);
753 trace_dump_call_end();
755 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX);
762 trace_context_bind_vs_state(struct pipe_context *_pipe,
765 struct trace_context *tr_ctx = trace_context(_pipe);
766 struct trace_shader *tr_shdr = trace_shader(_state);
767 struct pipe_context *pipe = tr_ctx->pipe;
768 void *state = tr_shdr ? tr_shdr->state : NULL;
770 trace_dump_call_begin("pipe_context", "bind_vs_state");
772 trace_dump_arg(ptr, pipe);
773 trace_dump_arg(ptr, state);
775 tr_ctx->curr.vs = tr_shdr;
777 if (tr_shdr && tr_shdr->replaced)
778 state = tr_shdr->replaced;
780 pipe->bind_vs_state(pipe, state);
782 trace_dump_call_end();
787 trace_context_delete_vs_state(struct pipe_context *_pipe,
790 struct trace_context *tr_ctx = trace_context(_pipe);
791 struct trace_shader *tr_shdr = trace_shader(_state);
792 struct pipe_context *pipe = tr_ctx->pipe;
793 void *state = tr_shdr->state;
795 trace_dump_call_begin("pipe_context", "delete_vs_state");
797 trace_dump_arg(ptr, pipe);
798 trace_dump_arg(ptr, state);
800 pipe->delete_vs_state(pipe, state);
802 trace_dump_call_end();
804 trace_shader_destroy(tr_ctx, tr_shdr);
809 trace_context_set_blend_color(struct pipe_context *_pipe,
810 const struct pipe_blend_color *state)
812 struct trace_context *tr_ctx = trace_context(_pipe);
813 struct pipe_context *pipe = tr_ctx->pipe;
815 trace_dump_call_begin("pipe_context", "set_blend_color");
817 trace_dump_arg(ptr, pipe);
818 trace_dump_arg(blend_color, state);
820 pipe->set_blend_color(pipe, state);
822 trace_dump_call_end();
827 trace_context_set_clip_state(struct pipe_context *_pipe,
828 const struct pipe_clip_state *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_clip_state");
835 trace_dump_arg(ptr, pipe);
836 trace_dump_arg(clip_state, state);
838 pipe->set_clip_state(pipe, state);
840 trace_dump_call_end();
845 trace_context_set_constant_buffer(struct pipe_context *_pipe,
846 uint shader, uint index,
847 const struct pipe_constant_buffer *buffer)
849 struct trace_context *tr_ctx = trace_context(_pipe);
850 struct pipe_context *pipe = tr_ctx->pipe;
853 trace_screen_user_buffer_update(_pipe->screen, buffer->buffer);
855 trace_dump_call_begin("pipe_context", "set_constant_buffer");
857 trace_dump_arg(ptr, pipe);
858 trace_dump_arg(uint, shader);
859 trace_dump_arg(uint, index);
860 trace_dump_arg(constant_buffer, buffer);
863 struct pipe_constant_buffer _buffer;
864 _buffer.buffer = trace_buffer_unwrap(tr_ctx, buffer->buffer);
865 pipe->set_constant_buffer(pipe, shader, index, &_buffer);
867 pipe->set_constant_buffer(pipe, shader, index, buffer);
870 trace_dump_call_end();
875 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
876 const struct pipe_framebuffer_state *state)
878 struct trace_context *tr_ctx = trace_context(_pipe);
879 struct pipe_context *pipe = tr_ctx->pipe;
880 struct pipe_framebuffer_state unwrapped_state;
884 tr_ctx->curr.nr_cbufs = state->nr_cbufs;
885 for (i = 0; i < state->nr_cbufs; i++)
887 tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture);
889 tr_ctx->curr.cbufs[i] = NULL;
891 tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture);
893 tr_ctx->curr.zsbuf = NULL;
896 /* Unwrap the input state */
897 memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
898 for(i = 0; i < state->nr_cbufs; ++i)
899 unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
900 for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
901 unwrapped_state.cbufs[i] = NULL;
902 unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
903 state = &unwrapped_state;
905 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
907 trace_dump_arg(ptr, pipe);
908 trace_dump_arg(framebuffer_state, state);
910 pipe->set_framebuffer_state(pipe, state);
912 trace_dump_call_end();
917 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
918 const struct pipe_poly_stipple *state)
920 struct trace_context *tr_ctx = trace_context(_pipe);
921 struct pipe_context *pipe = tr_ctx->pipe;
923 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
925 trace_dump_arg(ptr, pipe);
926 trace_dump_arg(poly_stipple, state);
928 pipe->set_polygon_stipple(pipe, state);
930 trace_dump_call_end();
935 trace_context_set_scissor_state(struct pipe_context *_pipe,
936 const struct pipe_scissor_state *state)
938 struct trace_context *tr_ctx = trace_context(_pipe);
939 struct pipe_context *pipe = tr_ctx->pipe;
941 trace_dump_call_begin("pipe_context", "set_scissor_state");
943 trace_dump_arg(ptr, pipe);
944 trace_dump_arg(scissor_state, state);
946 pipe->set_scissor_state(pipe, state);
948 trace_dump_call_end();
953 trace_context_set_viewport_state(struct pipe_context *_pipe,
954 const struct pipe_viewport_state *state)
956 struct trace_context *tr_ctx = trace_context(_pipe);
957 struct pipe_context *pipe = tr_ctx->pipe;
959 trace_dump_call_begin("pipe_context", "set_viewport_state");
961 trace_dump_arg(ptr, pipe);
962 trace_dump_arg(viewport_state, state);
964 pipe->set_viewport_state(pipe, state);
966 trace_dump_call_end();
971 trace_context_set_fragment_sampler_textures(struct pipe_context *_pipe,
972 unsigned num_textures,
973 struct pipe_texture **textures)
975 struct trace_context *tr_ctx = trace_context(_pipe);
976 struct trace_texture *tr_tex;
977 struct pipe_context *pipe = tr_ctx->pipe;
978 struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
981 tr_ctx->curr.num_texs = num_textures;
982 for(i = 0; i < num_textures; ++i) {
983 tr_tex = trace_texture(textures[i]);
984 tr_ctx->curr.tex[i] = tr_tex;
985 unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
987 textures = unwrapped_textures;
989 trace_dump_call_begin("pipe_context", "set_fragment_sampler_textures");
991 trace_dump_arg(ptr, pipe);
992 trace_dump_arg(uint, num_textures);
993 trace_dump_arg_array(ptr, textures, num_textures);
995 pipe->set_fragment_sampler_textures(pipe, num_textures, textures);
997 trace_dump_call_end();
1002 trace_context_set_vertex_sampler_textures(struct pipe_context *_pipe,
1003 unsigned num_textures,
1004 struct pipe_texture **textures)
1006 struct trace_context *tr_ctx = trace_context(_pipe);
1007 struct trace_texture *tr_tex;
1008 struct pipe_context *pipe = tr_ctx->pipe;
1009 struct pipe_texture *unwrapped_textures[PIPE_MAX_VERTEX_SAMPLERS];
1012 tr_ctx->curr.num_vert_texs = num_textures;
1013 for(i = 0; i < num_textures; ++i) {
1014 tr_tex = trace_texture(textures[i]);
1015 tr_ctx->curr.vert_tex[i] = tr_tex;
1016 unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
1018 textures = unwrapped_textures;
1020 trace_dump_call_begin("pipe_context", "set_vertex_sampler_textures");
1022 trace_dump_arg(ptr, pipe);
1023 trace_dump_arg(uint, num_textures);
1024 trace_dump_arg_array(ptr, textures, num_textures);
1026 pipe->set_vertex_sampler_textures(pipe, num_textures, textures);
1028 trace_dump_call_end();
1033 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1034 unsigned num_buffers,
1035 const struct pipe_vertex_buffer *buffers)
1037 struct trace_context *tr_ctx = trace_context(_pipe);
1038 struct pipe_context *pipe = tr_ctx->pipe;
1041 for(i = 0; i < num_buffers; ++i)
1042 trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
1044 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1046 trace_dump_arg(ptr, pipe);
1047 trace_dump_arg(uint, num_buffers);
1049 trace_dump_arg_begin("buffers");
1050 trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1051 trace_dump_arg_end();
1054 struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
1055 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1056 for (i = 0; i < num_buffers; i++)
1057 _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
1058 pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1061 pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1064 trace_dump_call_end();
1069 trace_context_set_vertex_elements(struct pipe_context *_pipe,
1070 unsigned num_elements,
1071 const struct pipe_vertex_element *elements)
1073 struct trace_context *tr_ctx = trace_context(_pipe);
1074 struct pipe_context *pipe = tr_ctx->pipe;
1076 trace_dump_call_begin("pipe_context", "set_vertex_elements");
1078 trace_dump_arg(ptr, pipe);
1079 trace_dump_arg(uint, num_elements);
1081 trace_dump_arg_begin("elements");
1082 trace_dump_struct_array(vertex_element, elements, num_elements);
1083 trace_dump_arg_end();
1085 pipe->set_vertex_elements(pipe, num_elements, elements);
1087 trace_dump_call_end();
1092 trace_context_surface_copy(struct pipe_context *_pipe,
1093 struct pipe_surface *dest,
1094 unsigned destx, unsigned desty,
1095 struct pipe_surface *src,
1096 unsigned srcx, unsigned srcy,
1097 unsigned width, unsigned height)
1099 struct trace_context *tr_ctx = trace_context(_pipe);
1100 struct pipe_context *pipe = tr_ctx->pipe;
1102 dest = trace_surface_unwrap(tr_ctx, dest);
1103 src = trace_surface_unwrap(tr_ctx, src);
1105 trace_dump_call_begin("pipe_context", "surface_copy");
1107 trace_dump_arg(ptr, pipe);
1108 trace_dump_arg(ptr, dest);
1109 trace_dump_arg(uint, destx);
1110 trace_dump_arg(uint, desty);
1111 trace_dump_arg(ptr, src);
1112 trace_dump_arg(uint, srcx);
1113 trace_dump_arg(uint, srcy);
1114 trace_dump_arg(uint, width);
1115 trace_dump_arg(uint, height);
1117 pipe->surface_copy(pipe,
1119 src, srcx, srcy, width, height);
1121 trace_dump_call_end();
1126 trace_context_surface_fill(struct pipe_context *_pipe,
1127 struct pipe_surface *dst,
1128 unsigned dstx, unsigned dsty,
1129 unsigned width, unsigned height,
1132 struct trace_context *tr_ctx = trace_context(_pipe);
1133 struct pipe_context *pipe = tr_ctx->pipe;
1135 dst = trace_surface_unwrap(tr_ctx, dst);
1137 trace_dump_call_begin("pipe_context", "surface_fill");
1139 trace_dump_arg(ptr, pipe);
1140 trace_dump_arg(ptr, dst);
1141 trace_dump_arg(uint, dstx);
1142 trace_dump_arg(uint, dsty);
1143 trace_dump_arg(uint, width);
1144 trace_dump_arg(uint, height);
1146 pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);
1148 trace_dump_call_end();
1153 trace_context_clear(struct pipe_context *_pipe,
1159 struct trace_context *tr_ctx = trace_context(_pipe);
1160 struct pipe_context *pipe = tr_ctx->pipe;
1162 trace_dump_call_begin("pipe_context", "clear");
1164 trace_dump_arg(ptr, pipe);
1165 trace_dump_arg(uint, buffers);
1166 trace_dump_arg_array(float, rgba, 4);
1167 trace_dump_arg(float, depth);
1168 trace_dump_arg(uint, stencil);
1170 pipe->clear(pipe, buffers, rgba, depth, stencil);
1172 trace_dump_call_end();
1177 trace_context_flush(struct pipe_context *_pipe,
1179 struct pipe_fence_handle **fence)
1181 struct trace_context *tr_ctx = trace_context(_pipe);
1182 struct pipe_context *pipe = tr_ctx->pipe;
1184 trace_dump_call_begin("pipe_context", "flush");
1186 trace_dump_arg(ptr, pipe);
1187 trace_dump_arg(uint, flags);
1189 pipe->flush(pipe, flags, fence);
1192 trace_dump_ret(ptr, *fence);
1194 trace_dump_call_end();
1199 trace_context_destroy(struct pipe_context *_pipe)
1201 struct trace_screen *tr_scr = trace_screen(_pipe->screen);
1202 struct trace_context *tr_ctx = trace_context(_pipe);
1203 struct pipe_context *pipe = tr_ctx->pipe;
1205 trace_dump_call_begin("pipe_context", "destroy");
1206 trace_dump_arg(ptr, pipe);
1207 trace_dump_call_end();
1209 trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
1211 pipe->destroy(pipe);
1217 trace_is_texture_referenced( struct pipe_context *_pipe,
1218 struct pipe_texture *_texture,
1219 unsigned face, unsigned level)
1221 struct trace_context *tr_ctx = trace_context(_pipe);
1222 struct trace_texture *tr_tex = trace_texture(_texture);
1223 struct pipe_context *pipe = tr_ctx->pipe;
1224 struct pipe_texture *texture = tr_tex->texture;
1225 unsigned int referenced;
1227 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1228 trace_dump_arg(ptr, pipe);
1229 trace_dump_arg(ptr, texture);
1230 trace_dump_arg(uint, face);
1231 trace_dump_arg(uint, level);
1233 referenced = pipe->is_texture_referenced(pipe, texture, face, level);
1235 trace_dump_ret(uint, referenced);
1236 trace_dump_call_end();
1242 trace_is_buffer_referenced( struct pipe_context *_pipe,
1243 struct pipe_buffer *_buf)
1245 struct trace_context *tr_ctx = trace_context(_pipe);
1246 struct trace_buffer *tr_buf = trace_buffer(_buf);
1247 struct pipe_context *pipe = tr_ctx->pipe;
1248 struct pipe_buffer *buf = tr_buf->buffer;
1249 unsigned int referenced;
1251 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1252 trace_dump_arg(ptr, pipe);
1253 trace_dump_arg(ptr, buf);
1255 referenced = pipe->is_buffer_referenced(pipe, buf);
1257 trace_dump_ret(uint, referenced);
1258 trace_dump_call_end();
1263 static const struct debug_named_value rbug_blocker_flags[] = {
1269 struct pipe_context *
1270 trace_context_create(struct pipe_screen *_screen,
1271 struct pipe_context *pipe)
1273 struct trace_screen *tr_scr;
1274 struct trace_context *tr_ctx;
1275 struct pipe_screen *screen;
1280 if(!trace_enabled())
1283 tr_scr = trace_screen(_screen);
1284 screen = tr_scr->screen;
1286 tr_ctx = CALLOC_STRUCT(trace_context);
1290 tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
1293 pipe_mutex_init(tr_ctx->draw_mutex);
1294 pipe_condvar_init(tr_ctx->draw_cond);
1295 pipe_mutex_init(tr_ctx->list_mutex);
1296 make_empty_list(&tr_ctx->shaders);
1298 tr_ctx->base.winsys = _screen->winsys;
1299 tr_ctx->base.screen = _screen;
1300 tr_ctx->base.destroy = trace_context_destroy;
1301 tr_ctx->base.set_edgeflags = trace_context_set_edgeflags;
1302 tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1303 tr_ctx->base.draw_elements = trace_context_draw_elements;
1304 tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1305 tr_ctx->base.create_query = trace_context_create_query;
1306 tr_ctx->base.destroy_query = trace_context_destroy_query;
1307 tr_ctx->base.begin_query = trace_context_begin_query;
1308 tr_ctx->base.end_query = trace_context_end_query;
1309 tr_ctx->base.get_query_result = trace_context_get_query_result;
1310 tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1311 tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1312 tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1313 tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1314 tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1315 tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1316 tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1317 tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1318 tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1319 tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1320 tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1321 tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1322 tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1323 tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1324 tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1325 tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1326 tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1327 tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1328 tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1329 tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1330 tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1331 tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1332 tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1333 tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1334 tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1335 tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1336 tr_ctx->base.set_fragment_sampler_textures = trace_context_set_fragment_sampler_textures;
1337 tr_ctx->base.set_vertex_sampler_textures = trace_context_set_vertex_sampler_textures;
1338 tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1339 tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
1340 if (pipe->surface_copy)
1341 tr_ctx->base.surface_copy = trace_context_surface_copy;
1342 if (pipe->surface_fill)
1343 tr_ctx->base.surface_fill = trace_context_surface_fill;
1344 tr_ctx->base.clear = trace_context_clear;
1345 tr_ctx->base.flush = trace_context_flush;
1346 tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
1347 tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
1349 tr_ctx->pipe = pipe;
1351 trace_dump_call_begin("", "pipe_context_create");
1352 trace_dump_arg(ptr, screen);
1353 trace_dump_ret(ptr, pipe);
1354 trace_dump_call_end();
1356 trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
1358 return &tr_ctx->base;