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
);
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
;
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_arrays");
195 trace_dump_arg(ptr
, pipe
);
196 trace_dump_arg(uint
, mode
);
197 trace_dump_arg(uint
, start
);
198 trace_dump_arg(uint
, count
);
200 pipe
->draw_arrays(pipe
, mode
, start
, count
);
202 trace_dump_call_end();
204 trace_context_draw_block(tr_ctx
, 2);
209 trace_context_draw_elements(struct pipe_context
*_pipe
,
210 struct pipe_buffer
*_indexBuffer
,
212 unsigned mode
, unsigned start
, unsigned count
)
214 struct trace_context
*tr_ctx
= trace_context(_pipe
);
215 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
216 struct pipe_context
*pipe
= tr_ctx
->pipe
;
217 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
219 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
222 trace_context_draw_block(tr_ctx
, 1);
224 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
226 trace_dump_call_begin("pipe_context", "draw_elements");
228 trace_dump_arg(ptr
, pipe
);
229 trace_dump_arg(ptr
, indexBuffer
);
230 trace_dump_arg(uint
, indexSize
);
231 trace_dump_arg(uint
, mode
);
232 trace_dump_arg(uint
, start
);
233 trace_dump_arg(uint
, count
);
235 pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);
237 trace_dump_call_end();
239 trace_context_draw_block(tr_ctx
, 2);
244 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
245 struct pipe_buffer
*_indexBuffer
,
253 struct trace_context
*tr_ctx
= trace_context(_pipe
);
254 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
255 struct pipe_context
*pipe
= tr_ctx
->pipe
;
256 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
258 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
261 trace_context_draw_block(tr_ctx
, 1);
263 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
265 trace_dump_call_begin("pipe_context", "draw_range_elements");
267 trace_dump_arg(ptr
, pipe
);
268 trace_dump_arg(ptr
, indexBuffer
);
269 trace_dump_arg(uint
, indexSize
);
270 trace_dump_arg(uint
, minIndex
);
271 trace_dump_arg(uint
, maxIndex
);
272 trace_dump_arg(uint
, mode
);
273 trace_dump_arg(uint
, start
);
274 trace_dump_arg(uint
, count
);
276 pipe
->draw_range_elements(pipe
,
278 indexSize
, minIndex
, maxIndex
,
281 trace_dump_call_end();
283 trace_context_draw_block(tr_ctx
, 2);
287 static INLINE
struct pipe_query
*
288 trace_context_create_query(struct pipe_context
*_pipe
,
291 struct trace_context
*tr_ctx
= trace_context(_pipe
);
292 struct pipe_context
*pipe
= tr_ctx
->pipe
;
293 struct pipe_query
*result
;
295 trace_dump_call_begin("pipe_context", "create_query");
297 trace_dump_arg(ptr
, pipe
);
298 trace_dump_arg(uint
, query_type
);
300 result
= pipe
->create_query(pipe
, query_type
);
302 trace_dump_ret(ptr
, result
);
304 trace_dump_call_end();
311 trace_context_destroy_query(struct pipe_context
*_pipe
,
312 struct pipe_query
*query
)
314 struct trace_context
*tr_ctx
= trace_context(_pipe
);
315 struct pipe_context
*pipe
= tr_ctx
->pipe
;
317 trace_dump_call_begin("pipe_context", "destroy_query");
319 trace_dump_arg(ptr
, pipe
);
320 trace_dump_arg(ptr
, query
);
322 pipe
->destroy_query(pipe
, query
);
324 trace_dump_call_end();
329 trace_context_begin_query(struct pipe_context
*_pipe
,
330 struct pipe_query
*query
)
332 struct trace_context
*tr_ctx
= trace_context(_pipe
);
333 struct pipe_context
*pipe
= tr_ctx
->pipe
;
335 trace_dump_call_begin("pipe_context", "begin_query");
337 trace_dump_arg(ptr
, pipe
);
338 trace_dump_arg(ptr
, query
);
340 pipe
->begin_query(pipe
, query
);
342 trace_dump_call_end();
347 trace_context_end_query(struct pipe_context
*_pipe
,
348 struct pipe_query
*query
)
350 struct trace_context
*tr_ctx
= trace_context(_pipe
);
351 struct pipe_context
*pipe
= tr_ctx
->pipe
;
353 trace_dump_call_begin("pipe_context", "end_query");
355 trace_dump_arg(ptr
, pipe
);
356 trace_dump_arg(ptr
, query
);
358 pipe
->end_query(pipe
, query
);
360 trace_dump_call_end();
364 static INLINE boolean
365 trace_context_get_query_result(struct pipe_context
*_pipe
,
366 struct pipe_query
*query
,
370 struct trace_context
*tr_ctx
= trace_context(_pipe
);
371 struct pipe_context
*pipe
= tr_ctx
->pipe
;
375 trace_dump_call_begin("pipe_context", "get_query_result");
377 trace_dump_arg(ptr
, pipe
);
379 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);
382 trace_dump_arg(uint
, result
);
383 trace_dump_ret(bool, _result
);
385 trace_dump_call_end();
392 trace_context_create_blend_state(struct pipe_context
*_pipe
,
393 const struct pipe_blend_state
*state
)
395 struct trace_context
*tr_ctx
= trace_context(_pipe
);
396 struct pipe_context
*pipe
= tr_ctx
->pipe
;
399 trace_dump_call_begin("pipe_context", "create_blend_state");
401 trace_dump_arg(ptr
, pipe
);
402 trace_dump_arg(blend_state
, state
);
404 result
= pipe
->create_blend_state(pipe
, state
);
406 trace_dump_ret(ptr
, result
);
408 trace_dump_call_end();
415 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
418 struct trace_context
*tr_ctx
= trace_context(_pipe
);
419 struct pipe_context
*pipe
= tr_ctx
->pipe
;
421 trace_dump_call_begin("pipe_context", "bind_blend_state");
423 trace_dump_arg(ptr
, pipe
);
424 trace_dump_arg(ptr
, state
);
426 pipe
->bind_blend_state(pipe
, state
);
428 trace_dump_call_end();
433 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
436 struct trace_context
*tr_ctx
= trace_context(_pipe
);
437 struct pipe_context
*pipe
= tr_ctx
->pipe
;
439 trace_dump_call_begin("pipe_context", "delete_blend_state");
441 trace_dump_arg(ptr
, pipe
);
442 trace_dump_arg(ptr
, state
);
444 pipe
->delete_blend_state(pipe
, state
);
446 trace_dump_call_end();
451 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
452 const struct pipe_sampler_state
*state
)
454 struct trace_context
*tr_ctx
= trace_context(_pipe
);
455 struct pipe_context
*pipe
= tr_ctx
->pipe
;
458 trace_dump_call_begin("pipe_context", "create_sampler_state");
460 trace_dump_arg(ptr
, pipe
);
461 trace_dump_arg(sampler_state
, state
);
463 result
= pipe
->create_sampler_state(pipe
, state
);
465 trace_dump_ret(ptr
, result
);
467 trace_dump_call_end();
474 trace_context_bind_fragment_sampler_states(struct pipe_context
*_pipe
,
478 struct trace_context
*tr_ctx
= trace_context(_pipe
);
479 struct pipe_context
*pipe
= tr_ctx
->pipe
;
481 trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
483 trace_dump_arg(ptr
, pipe
);
484 trace_dump_arg(uint
, num_states
);
485 trace_dump_arg_array(ptr
, states
, num_states
);
487 pipe
->bind_fragment_sampler_states(pipe
, num_states
, states
);
489 trace_dump_call_end();
494 trace_context_bind_vertex_sampler_states(struct pipe_context
*_pipe
,
498 struct trace_context
*tr_ctx
= trace_context(_pipe
);
499 struct pipe_context
*pipe
= tr_ctx
->pipe
;
501 trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
503 trace_dump_arg(ptr
, pipe
);
504 trace_dump_arg(uint
, num_states
);
505 trace_dump_arg_array(ptr
, states
, num_states
);
507 pipe
->bind_vertex_sampler_states(pipe
, num_states
, states
);
509 trace_dump_call_end();
514 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
517 struct trace_context
*tr_ctx
= trace_context(_pipe
);
518 struct pipe_context
*pipe
= tr_ctx
->pipe
;
520 trace_dump_call_begin("pipe_context", "delete_sampler_state");
522 trace_dump_arg(ptr
, pipe
);
523 trace_dump_arg(ptr
, state
);
525 pipe
->delete_sampler_state(pipe
, state
);
527 trace_dump_call_end();
532 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
533 const struct pipe_rasterizer_state
*state
)
535 struct trace_context
*tr_ctx
= trace_context(_pipe
);
536 struct pipe_context
*pipe
= tr_ctx
->pipe
;
539 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
541 trace_dump_arg(ptr
, pipe
);
542 trace_dump_arg(rasterizer_state
, state
);
544 result
= pipe
->create_rasterizer_state(pipe
, state
);
546 trace_dump_ret(ptr
, result
);
548 trace_dump_call_end();
555 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
558 struct trace_context
*tr_ctx
= trace_context(_pipe
);
559 struct pipe_context
*pipe
= tr_ctx
->pipe
;
561 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
563 trace_dump_arg(ptr
, pipe
);
564 trace_dump_arg(ptr
, state
);
566 pipe
->bind_rasterizer_state(pipe
, state
);
568 trace_dump_call_end();
573 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
576 struct trace_context
*tr_ctx
= trace_context(_pipe
);
577 struct pipe_context
*pipe
= tr_ctx
->pipe
;
579 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
581 trace_dump_arg(ptr
, pipe
);
582 trace_dump_arg(ptr
, state
);
584 pipe
->delete_rasterizer_state(pipe
, state
);
586 trace_dump_call_end();
591 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
592 const struct pipe_depth_stencil_alpha_state
*state
)
594 struct trace_context
*tr_ctx
= trace_context(_pipe
);
595 struct pipe_context
*pipe
= tr_ctx
->pipe
;
598 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
600 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);
602 trace_dump_arg(ptr
, pipe
);
603 trace_dump_arg(depth_stencil_alpha_state
, state
);
605 trace_dump_ret(ptr
, result
);
607 trace_dump_call_end();
614 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
617 struct trace_context
*tr_ctx
= trace_context(_pipe
);
618 struct pipe_context
*pipe
= tr_ctx
->pipe
;
620 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
622 trace_dump_arg(ptr
, pipe
);
623 trace_dump_arg(ptr
, state
);
625 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);
627 trace_dump_call_end();
632 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
635 struct trace_context
*tr_ctx
= trace_context(_pipe
);
636 struct pipe_context
*pipe
= tr_ctx
->pipe
;
638 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
640 trace_dump_arg(ptr
, pipe
);
641 trace_dump_arg(ptr
, state
);
643 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);
645 trace_dump_call_end();
650 trace_context_create_fs_state(struct pipe_context
*_pipe
,
651 const struct pipe_shader_state
*state
)
653 struct trace_context
*tr_ctx
= trace_context(_pipe
);
654 struct pipe_context
*pipe
= tr_ctx
->pipe
;
657 trace_dump_call_begin("pipe_context", "create_fs_state");
659 trace_dump_arg(ptr
, pipe
);
660 trace_dump_arg(shader_state
, state
);
662 result
= pipe
->create_fs_state(pipe
, state
);
664 trace_dump_ret(ptr
, result
);
666 trace_dump_call_end();
668 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
675 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
678 struct trace_context
*tr_ctx
= trace_context(_pipe
);
679 struct trace_shader
*tr_shdr
= trace_shader(_state
);
680 struct pipe_context
*pipe
= tr_ctx
->pipe
;
681 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
683 trace_dump_call_begin("pipe_context", "bind_fs_state");
685 trace_dump_arg(ptr
, pipe
);
686 trace_dump_arg(ptr
, state
);
688 tr_ctx
->curr
.fs
= tr_shdr
;
690 if (tr_shdr
&& tr_shdr
->replaced
)
691 state
= tr_shdr
->replaced
;
693 pipe
->bind_fs_state(pipe
, state
);
695 trace_dump_call_end();
700 trace_context_delete_fs_state(struct pipe_context
*_pipe
,
703 struct trace_context
*tr_ctx
= trace_context(_pipe
);
704 struct trace_shader
*tr_shdr
= trace_shader(_state
);
705 struct pipe_context
*pipe
= tr_ctx
->pipe
;
706 void *state
= tr_shdr
->state
;
708 trace_dump_call_begin("pipe_context", "delete_fs_state");
710 trace_dump_arg(ptr
, pipe
);
711 trace_dump_arg(ptr
, state
);
713 pipe
->delete_fs_state(pipe
, state
);
715 trace_dump_call_end();
717 trace_shader_destroy(tr_ctx
, tr_shdr
);
722 trace_context_create_vs_state(struct pipe_context
*_pipe
,
723 const struct pipe_shader_state
*state
)
725 struct trace_context
*tr_ctx
= trace_context(_pipe
);
726 struct pipe_context
*pipe
= tr_ctx
->pipe
;
729 trace_dump_call_begin("pipe_context", "create_vs_state");
731 trace_dump_arg(ptr
, pipe
);
732 trace_dump_arg(shader_state
, state
);
734 result
= pipe
->create_vs_state(pipe
, state
);
736 trace_dump_ret(ptr
, result
);
738 trace_dump_call_end();
740 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
747 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
750 struct trace_context
*tr_ctx
= trace_context(_pipe
);
751 struct trace_shader
*tr_shdr
= trace_shader(_state
);
752 struct pipe_context
*pipe
= tr_ctx
->pipe
;
753 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
755 trace_dump_call_begin("pipe_context", "bind_vs_state");
757 trace_dump_arg(ptr
, pipe
);
758 trace_dump_arg(ptr
, state
);
760 tr_ctx
->curr
.vs
= tr_shdr
;
762 if (tr_shdr
&& tr_shdr
->replaced
)
763 state
= tr_shdr
->replaced
;
765 pipe
->bind_vs_state(pipe
, state
);
767 trace_dump_call_end();
772 trace_context_delete_vs_state(struct pipe_context
*_pipe
,
775 struct trace_context
*tr_ctx
= trace_context(_pipe
);
776 struct trace_shader
*tr_shdr
= trace_shader(_state
);
777 struct pipe_context
*pipe
= tr_ctx
->pipe
;
778 void *state
= tr_shdr
->state
;
780 trace_dump_call_begin("pipe_context", "delete_vs_state");
782 trace_dump_arg(ptr
, pipe
);
783 trace_dump_arg(ptr
, state
);
785 pipe
->delete_vs_state(pipe
, state
);
787 trace_dump_call_end();
789 trace_shader_destroy(tr_ctx
, tr_shdr
);
794 trace_context_set_blend_color(struct pipe_context
*_pipe
,
795 const struct pipe_blend_color
*state
)
797 struct trace_context
*tr_ctx
= trace_context(_pipe
);
798 struct pipe_context
*pipe
= tr_ctx
->pipe
;
800 trace_dump_call_begin("pipe_context", "set_blend_color");
802 trace_dump_arg(ptr
, pipe
);
803 trace_dump_arg(blend_color
, state
);
805 pipe
->set_blend_color(pipe
, state
);
807 trace_dump_call_end();
812 trace_context_set_clip_state(struct pipe_context
*_pipe
,
813 const struct pipe_clip_state
*state
)
815 struct trace_context
*tr_ctx
= trace_context(_pipe
);
816 struct pipe_context
*pipe
= tr_ctx
->pipe
;
818 trace_dump_call_begin("pipe_context", "set_clip_state");
820 trace_dump_arg(ptr
, pipe
);
821 trace_dump_arg(clip_state
, state
);
823 pipe
->set_clip_state(pipe
, state
);
825 trace_dump_call_end();
830 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
831 uint shader
, uint index
,
832 const struct pipe_constant_buffer
*buffer
)
834 struct trace_context
*tr_ctx
= trace_context(_pipe
);
835 struct pipe_context
*pipe
= tr_ctx
->pipe
;
838 trace_screen_user_buffer_update(_pipe
->screen
, buffer
->buffer
);
840 trace_dump_call_begin("pipe_context", "set_constant_buffer");
842 trace_dump_arg(ptr
, pipe
);
843 trace_dump_arg(uint
, shader
);
844 trace_dump_arg(uint
, index
);
845 trace_dump_arg(constant_buffer
, buffer
);
848 struct pipe_constant_buffer _buffer
;
849 _buffer
.buffer
= trace_buffer_unwrap(tr_ctx
, buffer
->buffer
);
850 pipe
->set_constant_buffer(pipe
, shader
, index
, &_buffer
);
852 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
855 trace_dump_call_end();
860 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
861 const struct pipe_framebuffer_state
*state
)
863 struct trace_context
*tr_ctx
= trace_context(_pipe
);
864 struct pipe_context
*pipe
= tr_ctx
->pipe
;
865 struct pipe_framebuffer_state unwrapped_state
;
869 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
870 for (i
= 0; i
< state
->nr_cbufs
; i
++)
872 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
874 tr_ctx
->curr
.cbufs
[i
] = NULL
;
876 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
878 tr_ctx
->curr
.zsbuf
= NULL
;
881 /* Unwrap the input state */
882 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
883 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
884 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
885 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
886 unwrapped_state
.cbufs
[i
] = NULL
;
887 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
888 state
= &unwrapped_state
;
890 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
892 trace_dump_arg(ptr
, pipe
);
893 trace_dump_arg(framebuffer_state
, state
);
895 pipe
->set_framebuffer_state(pipe
, state
);
897 trace_dump_call_end();
902 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
903 const struct pipe_poly_stipple
*state
)
905 struct trace_context
*tr_ctx
= trace_context(_pipe
);
906 struct pipe_context
*pipe
= tr_ctx
->pipe
;
908 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
910 trace_dump_arg(ptr
, pipe
);
911 trace_dump_arg(poly_stipple
, state
);
913 pipe
->set_polygon_stipple(pipe
, state
);
915 trace_dump_call_end();
920 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
921 const struct pipe_scissor_state
*state
)
923 struct trace_context
*tr_ctx
= trace_context(_pipe
);
924 struct pipe_context
*pipe
= tr_ctx
->pipe
;
926 trace_dump_call_begin("pipe_context", "set_scissor_state");
928 trace_dump_arg(ptr
, pipe
);
929 trace_dump_arg(scissor_state
, state
);
931 pipe
->set_scissor_state(pipe
, state
);
933 trace_dump_call_end();
938 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
939 const struct pipe_viewport_state
*state
)
941 struct trace_context
*tr_ctx
= trace_context(_pipe
);
942 struct pipe_context
*pipe
= tr_ctx
->pipe
;
944 trace_dump_call_begin("pipe_context", "set_viewport_state");
946 trace_dump_arg(ptr
, pipe
);
947 trace_dump_arg(viewport_state
, state
);
949 pipe
->set_viewport_state(pipe
, state
);
951 trace_dump_call_end();
956 trace_context_set_fragment_sampler_textures(struct pipe_context
*_pipe
,
957 unsigned num_textures
,
958 struct pipe_texture
**textures
)
960 struct trace_context
*tr_ctx
= trace_context(_pipe
);
961 struct trace_texture
*tr_tex
;
962 struct pipe_context
*pipe
= tr_ctx
->pipe
;
963 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
966 tr_ctx
->curr
.num_texs
= num_textures
;
967 for(i
= 0; i
< num_textures
; ++i
) {
968 tr_tex
= trace_texture(textures
[i
]);
969 tr_ctx
->curr
.tex
[i
] = tr_tex
;
970 unwrapped_textures
[i
] = tr_tex
? tr_tex
->texture
: NULL
;
972 textures
= unwrapped_textures
;
974 trace_dump_call_begin("pipe_context", "set_fragment_sampler_textures");
976 trace_dump_arg(ptr
, pipe
);
977 trace_dump_arg(uint
, num_textures
);
978 trace_dump_arg_array(ptr
, textures
, num_textures
);
980 pipe
->set_fragment_sampler_textures(pipe
, num_textures
, textures
);
982 trace_dump_call_end();
987 trace_context_set_vertex_sampler_textures(struct pipe_context
*_pipe
,
988 unsigned num_textures
,
989 struct pipe_texture
**textures
)
991 struct trace_context
*tr_ctx
= trace_context(_pipe
);
992 struct trace_texture
*tr_tex
;
993 struct pipe_context
*pipe
= tr_ctx
->pipe
;
994 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_VERTEX_SAMPLERS
];
997 tr_ctx
->curr
.num_vert_texs
= num_textures
;
998 for(i
= 0; i
< num_textures
; ++i
) {
999 tr_tex
= trace_texture(textures
[i
]);
1000 tr_ctx
->curr
.vert_tex
[i
] = tr_tex
;
1001 unwrapped_textures
[i
] = tr_tex
? tr_tex
->texture
: NULL
;
1003 textures
= unwrapped_textures
;
1005 trace_dump_call_begin("pipe_context", "set_vertex_sampler_textures");
1007 trace_dump_arg(ptr
, pipe
);
1008 trace_dump_arg(uint
, num_textures
);
1009 trace_dump_arg_array(ptr
, textures
, num_textures
);
1011 pipe
->set_vertex_sampler_textures(pipe
, num_textures
, textures
);
1013 trace_dump_call_end();
1018 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
1019 unsigned num_buffers
,
1020 const struct pipe_vertex_buffer
*buffers
)
1022 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1023 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1026 for(i
= 0; i
< num_buffers
; ++i
)
1027 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
1029 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1031 trace_dump_arg(ptr
, pipe
);
1032 trace_dump_arg(uint
, num_buffers
);
1034 trace_dump_arg_begin("buffers");
1035 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
1036 trace_dump_arg_end();
1039 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
1040 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
1041 for (i
= 0; i
< num_buffers
; i
++)
1042 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
1043 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
1046 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
1049 trace_dump_call_end();
1054 trace_context_set_vertex_elements(struct pipe_context
*_pipe
,
1055 unsigned num_elements
,
1056 const struct pipe_vertex_element
*elements
)
1058 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1059 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1061 trace_dump_call_begin("pipe_context", "set_vertex_elements");
1063 trace_dump_arg(ptr
, pipe
);
1064 trace_dump_arg(uint
, num_elements
);
1066 trace_dump_arg_begin("elements");
1067 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
1068 trace_dump_arg_end();
1070 pipe
->set_vertex_elements(pipe
, num_elements
, elements
);
1072 trace_dump_call_end();
1077 trace_context_surface_copy(struct pipe_context
*_pipe
,
1078 struct pipe_surface
*dest
,
1079 unsigned destx
, unsigned desty
,
1080 struct pipe_surface
*src
,
1081 unsigned srcx
, unsigned srcy
,
1082 unsigned width
, unsigned height
)
1084 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1085 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1087 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1088 src
= trace_surface_unwrap(tr_ctx
, src
);
1090 trace_dump_call_begin("pipe_context", "surface_copy");
1092 trace_dump_arg(ptr
, pipe
);
1093 trace_dump_arg(ptr
, dest
);
1094 trace_dump_arg(uint
, destx
);
1095 trace_dump_arg(uint
, desty
);
1096 trace_dump_arg(ptr
, src
);
1097 trace_dump_arg(uint
, srcx
);
1098 trace_dump_arg(uint
, srcy
);
1099 trace_dump_arg(uint
, width
);
1100 trace_dump_arg(uint
, height
);
1102 pipe
->surface_copy(pipe
,
1104 src
, srcx
, srcy
, width
, height
);
1106 trace_dump_call_end();
1111 trace_context_surface_fill(struct pipe_context
*_pipe
,
1112 struct pipe_surface
*dst
,
1113 unsigned dstx
, unsigned dsty
,
1114 unsigned width
, unsigned height
,
1117 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1118 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1120 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1122 trace_dump_call_begin("pipe_context", "surface_fill");
1124 trace_dump_arg(ptr
, pipe
);
1125 trace_dump_arg(ptr
, dst
);
1126 trace_dump_arg(uint
, dstx
);
1127 trace_dump_arg(uint
, dsty
);
1128 trace_dump_arg(uint
, width
);
1129 trace_dump_arg(uint
, height
);
1131 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);
1133 trace_dump_call_end();
1138 trace_context_clear(struct pipe_context
*_pipe
,
1144 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1145 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1147 trace_dump_call_begin("pipe_context", "clear");
1149 trace_dump_arg(ptr
, pipe
);
1150 trace_dump_arg(uint
, buffers
);
1151 trace_dump_arg_array(float, rgba
, 4);
1152 trace_dump_arg(float, depth
);
1153 trace_dump_arg(uint
, stencil
);
1155 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1157 trace_dump_call_end();
1162 trace_context_flush(struct pipe_context
*_pipe
,
1164 struct pipe_fence_handle
**fence
)
1166 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1167 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1169 trace_dump_call_begin("pipe_context", "flush");
1171 trace_dump_arg(ptr
, pipe
);
1172 trace_dump_arg(uint
, flags
);
1174 pipe
->flush(pipe
, flags
, fence
);
1177 trace_dump_ret(ptr
, *fence
);
1179 trace_dump_call_end();
1184 trace_context_destroy(struct pipe_context
*_pipe
)
1186 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1187 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1188 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1190 trace_dump_call_begin("pipe_context", "destroy");
1191 trace_dump_arg(ptr
, pipe
);
1192 trace_dump_call_end();
1194 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1196 pipe
->destroy(pipe
);
1202 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1203 struct pipe_texture
*_texture
,
1204 unsigned face
, unsigned level
)
1206 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1207 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1208 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1209 struct pipe_texture
*texture
= tr_tex
->texture
;
1210 unsigned int referenced
;
1212 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1213 trace_dump_arg(ptr
, pipe
);
1214 trace_dump_arg(ptr
, texture
);
1215 trace_dump_arg(uint
, face
);
1216 trace_dump_arg(uint
, level
);
1218 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1220 trace_dump_ret(uint
, referenced
);
1221 trace_dump_call_end();
1227 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1228 struct pipe_buffer
*_buf
)
1230 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1231 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1232 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1233 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1234 unsigned int referenced
;
1236 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1237 trace_dump_arg(ptr
, pipe
);
1238 trace_dump_arg(ptr
, buf
);
1240 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1242 trace_dump_ret(uint
, referenced
);
1243 trace_dump_call_end();
1248 static const struct debug_named_value rbug_blocker_flags
[] = {
1254 struct pipe_context
*
1255 trace_context_create(struct pipe_screen
*_screen
,
1256 struct pipe_context
*pipe
)
1258 struct trace_screen
*tr_scr
;
1259 struct trace_context
*tr_ctx
;
1260 struct pipe_screen
*screen
;
1265 if(!trace_enabled())
1268 tr_scr
= trace_screen(_screen
);
1269 screen
= tr_scr
->screen
;
1271 tr_ctx
= CALLOC_STRUCT(trace_context
);
1275 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1278 pipe_mutex_init(tr_ctx
->draw_mutex
);
1279 pipe_condvar_init(tr_ctx
->draw_cond
);
1280 pipe_mutex_init(tr_ctx
->list_mutex
);
1281 make_empty_list(&tr_ctx
->shaders
);
1283 tr_ctx
->base
.winsys
= _screen
->winsys
;
1284 tr_ctx
->base
.screen
= _screen
;
1285 tr_ctx
->base
.destroy
= trace_context_destroy
;
1286 tr_ctx
->base
.set_edgeflags
= trace_context_set_edgeflags
;
1287 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1288 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1289 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1290 tr_ctx
->base
.create_query
= trace_context_create_query
;
1291 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1292 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1293 tr_ctx
->base
.end_query
= trace_context_end_query
;
1294 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1295 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1296 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1297 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1298 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1299 tr_ctx
->base
.bind_fragment_sampler_states
= trace_context_bind_fragment_sampler_states
;
1300 tr_ctx
->base
.bind_vertex_sampler_states
= trace_context_bind_vertex_sampler_states
;
1301 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1302 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1303 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1304 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1305 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1306 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1307 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1308 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1309 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1310 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1311 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1312 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1313 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1314 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1315 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1316 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1317 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1318 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1319 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1320 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1321 tr_ctx
->base
.set_fragment_sampler_textures
= trace_context_set_fragment_sampler_textures
;
1322 tr_ctx
->base
.set_vertex_sampler_textures
= trace_context_set_vertex_sampler_textures
;
1323 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1324 tr_ctx
->base
.set_vertex_elements
= trace_context_set_vertex_elements
;
1325 if (pipe
->surface_copy
)
1326 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1327 if (pipe
->surface_fill
)
1328 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1329 tr_ctx
->base
.clear
= trace_context_clear
;
1330 tr_ctx
->base
.flush
= trace_context_flush
;
1331 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1332 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1334 tr_ctx
->pipe
= pipe
;
1336 trace_dump_call_begin("", "pipe_context_create");
1337 trace_dump_arg(ptr
, screen
);
1338 trace_dump_ret(ptr
, pipe
);
1339 trace_dump_call_end();
1341 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1343 return &tr_ctx
->base
;