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
;