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
);
56 return tr_buf
->buffer
;
60 static INLINE
struct pipe_texture
*
61 trace_texture_unwrap(struct trace_context
*tr_ctx
,
62 struct pipe_texture
*texture
)
64 struct trace_texture
*tr_tex
;
69 tr_tex
= trace_texture(texture
);
71 assert(tr_tex
->texture
);
72 return tr_tex
->texture
;
76 static INLINE
struct pipe_surface
*
77 trace_surface_unwrap(struct trace_context
*tr_ctx
,
78 struct pipe_surface
*surface
)
80 struct trace_screen
*tr_scr
= trace_screen(tr_ctx
->base
.screen
);
81 struct trace_surface
*tr_surf
;
86 assert(surface
->texture
);
90 tr_surf
= trace_surface(surface
);
92 assert(tr_surf
->surface
);
93 assert(tr_surf
->surface
->texture
->screen
== tr_scr
->screen
);
95 return tr_surf
->surface
;
100 trace_context_set_edgeflags(struct pipe_context
*_pipe
,
101 const unsigned *bitfield
)
103 struct trace_context
*tr_ctx
= trace_context(_pipe
);
104 struct pipe_context
*pipe
= tr_ctx
->pipe
;
106 trace_dump_call_begin("pipe_context", "set_edgeflags");
108 trace_dump_arg(ptr
, pipe
);
109 /* FIXME: we don't know how big this array is */
110 trace_dump_arg(ptr
, bitfield
);
112 pipe
->set_edgeflags(pipe
, bitfield
);;
114 trace_dump_call_end();
119 trace_context_draw_block(struct trace_context
*tr_ctx
, int flag
)
123 pipe_mutex_lock(tr_ctx
->draw_mutex
);
125 if (tr_ctx
->draw_blocker
& flag
) {
126 tr_ctx
->draw_blocked
|= flag
;
127 } else if ((tr_ctx
->draw_rule
.blocker
& flag
) &&
128 (tr_ctx
->draw_blocker
& 4)) {
129 boolean block
= FALSE
;
130 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__
,
131 (void *) tr_ctx
->draw_rule
.fs
, (void *) tr_ctx
->curr
.fs
,
132 (void *) tr_ctx
->draw_rule
.vs
, (void *) tr_ctx
->curr
.vs
,
133 (void *) tr_ctx
->draw_rule
.surf
, 0,
134 (void *) tr_ctx
->draw_rule
.tex
, 0);
135 if (tr_ctx
->draw_rule
.fs
&&
136 tr_ctx
->draw_rule
.fs
== tr_ctx
->curr
.fs
)
138 if (tr_ctx
->draw_rule
.vs
&&
139 tr_ctx
->draw_rule
.vs
== tr_ctx
->curr
.vs
)
141 if (tr_ctx
->draw_rule
.surf
&&
142 tr_ctx
->draw_rule
.surf
== tr_ctx
->curr
.zsbuf
)
144 if (tr_ctx
->draw_rule
.surf
)
145 for (k
= 0; k
< tr_ctx
->curr
.nr_cbufs
; k
++)
146 if (tr_ctx
->draw_rule
.surf
== tr_ctx
->curr
.cbufs
[k
])
148 if (tr_ctx
->draw_rule
.tex
)
149 for (k
= 0; k
< tr_ctx
->curr
.num_texs
; k
++)
150 if (tr_ctx
->draw_rule
.tex
== tr_ctx
->curr
.tex
[k
])
154 tr_ctx
->draw_blocked
|= (flag
| 4);
157 if (tr_ctx
->draw_blocked
)
158 trace_rbug_notify_draw_blocked(tr_ctx
);
160 /* wait for rbug to clear the blocked flag */
161 while (tr_ctx
->draw_blocked
& flag
) {
162 tr_ctx
->draw_blocked
|= flag
;
163 #ifdef PIPE_THREAD_HAVE_CONDVAR
164 pipe_condvar_wait(tr_ctx
->draw_cond
, tr_ctx
->draw_mutex
);
166 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
167 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
170 pipe_mutex_lock(tr_ctx
->draw_mutex
);
174 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
177 static INLINE boolean
178 trace_context_draw_arrays(struct pipe_context
*_pipe
,
179 unsigned mode
, unsigned start
, unsigned count
)
181 struct trace_context
*tr_ctx
= trace_context(_pipe
);
182 struct pipe_context
*pipe
= tr_ctx
->pipe
;
185 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
188 trace_context_draw_block(tr_ctx
, 1);
190 trace_dump_call_begin("pipe_context", "draw_arrays");
192 trace_dump_arg(ptr
, pipe
);
193 trace_dump_arg(uint
, mode
);
194 trace_dump_arg(uint
, start
);
195 trace_dump_arg(uint
, count
);
197 result
= pipe
->draw_arrays(pipe
, mode
, start
, count
);;
199 trace_dump_ret(bool, result
);
201 trace_dump_call_end();
203 trace_context_draw_block(tr_ctx
, 2);
209 static INLINE boolean
210 trace_context_draw_elements(struct pipe_context
*_pipe
,
211 struct pipe_buffer
*_indexBuffer
,
213 unsigned mode
, unsigned start
, unsigned count
)
215 struct trace_context
*tr_ctx
= trace_context(_pipe
);
216 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
217 struct pipe_context
*pipe
= tr_ctx
->pipe
;
218 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
221 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
224 trace_context_draw_block(tr_ctx
, 1);
226 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
228 trace_dump_call_begin("pipe_context", "draw_elements");
230 trace_dump_arg(ptr
, pipe
);
231 trace_dump_arg(ptr
, indexBuffer
);
232 trace_dump_arg(uint
, indexSize
);
233 trace_dump_arg(uint
, mode
);
234 trace_dump_arg(uint
, start
);
235 trace_dump_arg(uint
, count
);
237 result
= pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);;
239 trace_dump_ret(bool, result
);
241 trace_dump_call_end();
243 trace_context_draw_block(tr_ctx
, 2);
249 static INLINE boolean
250 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
251 struct pipe_buffer
*_indexBuffer
,
259 struct trace_context
*tr_ctx
= trace_context(_pipe
);
260 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
261 struct pipe_context
*pipe
= tr_ctx
->pipe
;
262 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
265 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
268 trace_context_draw_block(tr_ctx
, 1);
270 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
272 trace_dump_call_begin("pipe_context", "draw_range_elements");
274 trace_dump_arg(ptr
, pipe
);
275 trace_dump_arg(ptr
, indexBuffer
);
276 trace_dump_arg(uint
, indexSize
);
277 trace_dump_arg(uint
, minIndex
);
278 trace_dump_arg(uint
, maxIndex
);
279 trace_dump_arg(uint
, mode
);
280 trace_dump_arg(uint
, start
);
281 trace_dump_arg(uint
, count
);
283 result
= pipe
->draw_range_elements(pipe
,
285 indexSize
, minIndex
, maxIndex
,
288 trace_dump_ret(bool, result
);
290 trace_dump_call_end();
292 trace_context_draw_block(tr_ctx
, 2);
298 static INLINE
struct pipe_query
*
299 trace_context_create_query(struct pipe_context
*_pipe
,
302 struct trace_context
*tr_ctx
= trace_context(_pipe
);
303 struct pipe_context
*pipe
= tr_ctx
->pipe
;
304 struct pipe_query
*result
;
306 trace_dump_call_begin("pipe_context", "create_query");
308 trace_dump_arg(ptr
, pipe
);
309 trace_dump_arg(uint
, query_type
);
311 result
= pipe
->create_query(pipe
, query_type
);;
313 trace_dump_ret(ptr
, result
);
315 trace_dump_call_end();
322 trace_context_destroy_query(struct pipe_context
*_pipe
,
323 struct pipe_query
*query
)
325 struct trace_context
*tr_ctx
= trace_context(_pipe
);
326 struct pipe_context
*pipe
= tr_ctx
->pipe
;
328 trace_dump_call_begin("pipe_context", "destroy_query");
330 trace_dump_arg(ptr
, pipe
);
331 trace_dump_arg(ptr
, query
);
333 pipe
->destroy_query(pipe
, query
);;
335 trace_dump_call_end();
340 trace_context_begin_query(struct pipe_context
*_pipe
,
341 struct pipe_query
*query
)
343 struct trace_context
*tr_ctx
= trace_context(_pipe
);
344 struct pipe_context
*pipe
= tr_ctx
->pipe
;
346 trace_dump_call_begin("pipe_context", "begin_query");
348 trace_dump_arg(ptr
, pipe
);
349 trace_dump_arg(ptr
, query
);
351 pipe
->begin_query(pipe
, query
);;
353 trace_dump_call_end();
358 trace_context_end_query(struct pipe_context
*_pipe
,
359 struct pipe_query
*query
)
361 struct trace_context
*tr_ctx
= trace_context(_pipe
);
362 struct pipe_context
*pipe
= tr_ctx
->pipe
;
364 trace_dump_call_begin("pipe_context", "end_query");
366 trace_dump_arg(ptr
, pipe
);
367 trace_dump_arg(ptr
, query
);
369 pipe
->end_query(pipe
, query
);
371 trace_dump_call_end();
375 static INLINE boolean
376 trace_context_get_query_result(struct pipe_context
*_pipe
,
377 struct pipe_query
*query
,
381 struct trace_context
*tr_ctx
= trace_context(_pipe
);
382 struct pipe_context
*pipe
= tr_ctx
->pipe
;
386 trace_dump_call_begin("pipe_context", "get_query_result");
388 trace_dump_arg(ptr
, pipe
);
390 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);;
393 trace_dump_arg(uint
, result
);
394 trace_dump_ret(bool, _result
);
396 trace_dump_call_end();
403 trace_context_create_blend_state(struct pipe_context
*_pipe
,
404 const struct pipe_blend_state
*state
)
406 struct trace_context
*tr_ctx
= trace_context(_pipe
);
407 struct pipe_context
*pipe
= tr_ctx
->pipe
;
410 trace_dump_call_begin("pipe_context", "create_blend_state");
412 trace_dump_arg(ptr
, pipe
);
413 trace_dump_arg(blend_state
, state
);
415 result
= pipe
->create_blend_state(pipe
, state
);;
417 trace_dump_ret(ptr
, result
);
419 trace_dump_call_end();
426 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
429 struct trace_context
*tr_ctx
= trace_context(_pipe
);
430 struct pipe_context
*pipe
= tr_ctx
->pipe
;
432 trace_dump_call_begin("pipe_context", "bind_blend_state");
434 trace_dump_arg(ptr
, pipe
);
435 trace_dump_arg(ptr
, state
);
437 pipe
->bind_blend_state(pipe
, state
);;
439 trace_dump_call_end();
444 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
447 struct trace_context
*tr_ctx
= trace_context(_pipe
);
448 struct pipe_context
*pipe
= tr_ctx
->pipe
;
450 trace_dump_call_begin("pipe_context", "delete_blend_state");
452 trace_dump_arg(ptr
, pipe
);
453 trace_dump_arg(ptr
, state
);
455 pipe
->delete_blend_state(pipe
, state
);;
457 trace_dump_call_end();
462 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
463 const struct pipe_sampler_state
*state
)
465 struct trace_context
*tr_ctx
= trace_context(_pipe
);
466 struct pipe_context
*pipe
= tr_ctx
->pipe
;
469 trace_dump_call_begin("pipe_context", "create_sampler_state");
471 trace_dump_arg(ptr
, pipe
);
472 trace_dump_arg(sampler_state
, state
);
474 result
= pipe
->create_sampler_state(pipe
, state
);;
476 trace_dump_ret(ptr
, result
);
478 trace_dump_call_end();
485 trace_context_bind_sampler_states(struct pipe_context
*_pipe
,
486 unsigned num_states
, void **states
)
488 struct trace_context
*tr_ctx
= trace_context(_pipe
);
489 struct pipe_context
*pipe
= tr_ctx
->pipe
;
491 trace_dump_call_begin("pipe_context", "bind_sampler_states");
493 trace_dump_arg(ptr
, pipe
);
494 trace_dump_arg(uint
, num_states
);
495 trace_dump_arg_array(ptr
, states
, num_states
);
497 pipe
->bind_sampler_states(pipe
, num_states
, states
);;
499 trace_dump_call_end();
504 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
507 struct trace_context
*tr_ctx
= trace_context(_pipe
);
508 struct pipe_context
*pipe
= tr_ctx
->pipe
;
510 trace_dump_call_begin("pipe_context", "delete_sampler_state");
512 trace_dump_arg(ptr
, pipe
);
513 trace_dump_arg(ptr
, state
);
515 pipe
->delete_sampler_state(pipe
, state
);;
517 trace_dump_call_end();
522 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
523 const struct pipe_rasterizer_state
*state
)
525 struct trace_context
*tr_ctx
= trace_context(_pipe
);
526 struct pipe_context
*pipe
= tr_ctx
->pipe
;
529 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
531 trace_dump_arg(ptr
, pipe
);
532 trace_dump_arg(rasterizer_state
, state
);
534 result
= pipe
->create_rasterizer_state(pipe
, state
);;
536 trace_dump_ret(ptr
, result
);
538 trace_dump_call_end();
545 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
548 struct trace_context
*tr_ctx
= trace_context(_pipe
);
549 struct pipe_context
*pipe
= tr_ctx
->pipe
;
551 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
553 trace_dump_arg(ptr
, pipe
);
554 trace_dump_arg(ptr
, state
);
556 pipe
->bind_rasterizer_state(pipe
, state
);;
558 trace_dump_call_end();
563 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
566 struct trace_context
*tr_ctx
= trace_context(_pipe
);
567 struct pipe_context
*pipe
= tr_ctx
->pipe
;
569 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
571 trace_dump_arg(ptr
, pipe
);
572 trace_dump_arg(ptr
, state
);
574 pipe
->delete_rasterizer_state(pipe
, state
);;
576 trace_dump_call_end();
581 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
582 const struct pipe_depth_stencil_alpha_state
*state
)
584 struct trace_context
*tr_ctx
= trace_context(_pipe
);
585 struct pipe_context
*pipe
= tr_ctx
->pipe
;
588 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
590 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);;
592 trace_dump_arg(ptr
, pipe
);
593 trace_dump_arg(depth_stencil_alpha_state
, state
);
595 trace_dump_ret(ptr
, result
);
597 trace_dump_call_end();
604 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
607 struct trace_context
*tr_ctx
= trace_context(_pipe
);
608 struct pipe_context
*pipe
= tr_ctx
->pipe
;
610 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
612 trace_dump_arg(ptr
, pipe
);
613 trace_dump_arg(ptr
, state
);
615 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);;
617 trace_dump_call_end();
622 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
625 struct trace_context
*tr_ctx
= trace_context(_pipe
);
626 struct pipe_context
*pipe
= tr_ctx
->pipe
;
628 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
630 trace_dump_arg(ptr
, pipe
);
631 trace_dump_arg(ptr
, state
);
633 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);;
635 trace_dump_call_end();
640 trace_context_create_fs_state(struct pipe_context
*_pipe
,
641 const struct pipe_shader_state
*state
)
643 struct trace_context
*tr_ctx
= trace_context(_pipe
);
644 struct pipe_context
*pipe
= tr_ctx
->pipe
;
647 trace_dump_call_begin("pipe_context", "create_fs_state");
649 trace_dump_arg(ptr
, pipe
);
650 trace_dump_arg(shader_state
, state
);
652 result
= pipe
->create_fs_state(pipe
, state
);;
654 trace_dump_ret(ptr
, result
);
656 trace_dump_call_end();
658 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
665 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
668 struct trace_context
*tr_ctx
= trace_context(_pipe
);
669 struct trace_shader
*tr_shdr
= trace_shader(_state
);
670 struct pipe_context
*pipe
= tr_ctx
->pipe
;
671 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
673 trace_dump_call_begin("pipe_context", "bind_fs_state");
675 trace_dump_arg(ptr
, pipe
);
676 trace_dump_arg(ptr
, state
);
678 tr_ctx
->curr
.fs
= tr_shdr
;
680 if (tr_shdr
&& tr_shdr
->replaced
)
681 state
= tr_shdr
->replaced
;
683 pipe
->bind_fs_state(pipe
, state
);
685 trace_dump_call_end();
690 trace_context_delete_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
->state
;
698 trace_dump_call_begin("pipe_context", "delete_fs_state");
700 trace_dump_arg(ptr
, pipe
);
701 trace_dump_arg(ptr
, state
);
703 pipe
->delete_fs_state(pipe
, state
);
705 trace_dump_call_end();
707 trace_shader_destroy(tr_ctx
, tr_shdr
);
712 trace_context_create_vs_state(struct pipe_context
*_pipe
,
713 const struct pipe_shader_state
*state
)
715 struct trace_context
*tr_ctx
= trace_context(_pipe
);
716 struct pipe_context
*pipe
= tr_ctx
->pipe
;
719 trace_dump_call_begin("pipe_context", "create_vs_state");
721 trace_dump_arg(ptr
, pipe
);
722 trace_dump_arg(shader_state
, state
);
724 result
= pipe
->create_vs_state(pipe
, state
);
726 trace_dump_ret(ptr
, result
);
728 trace_dump_call_end();
730 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
737 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
740 struct trace_context
*tr_ctx
= trace_context(_pipe
);
741 struct trace_shader
*tr_shdr
= trace_shader(_state
);
742 struct pipe_context
*pipe
= tr_ctx
->pipe
;
743 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
745 trace_dump_call_begin("pipe_context", "bind_vs_state");
747 trace_dump_arg(ptr
, pipe
);
748 trace_dump_arg(ptr
, state
);
750 tr_ctx
->curr
.vs
= tr_shdr
;
752 if (tr_shdr
&& tr_shdr
->replaced
)
753 state
= tr_shdr
->replaced
;
755 pipe
->bind_vs_state(pipe
, state
);;
757 trace_dump_call_end();
762 trace_context_delete_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
->state
;
770 trace_dump_call_begin("pipe_context", "delete_vs_state");
772 trace_dump_arg(ptr
, pipe
);
773 trace_dump_arg(ptr
, state
);
775 pipe
->delete_vs_state(pipe
, state
);;
777 trace_dump_call_end();
779 trace_shader_destroy(tr_ctx
, tr_shdr
);
784 trace_context_set_blend_color(struct pipe_context
*_pipe
,
785 const struct pipe_blend_color
*state
)
787 struct trace_context
*tr_ctx
= trace_context(_pipe
);
788 struct pipe_context
*pipe
= tr_ctx
->pipe
;
790 trace_dump_call_begin("pipe_context", "set_blend_color");
792 trace_dump_arg(ptr
, pipe
);
793 trace_dump_arg(blend_color
, state
);
795 pipe
->set_blend_color(pipe
, state
);;
797 trace_dump_call_end();
802 trace_context_set_clip_state(struct pipe_context
*_pipe
,
803 const struct pipe_clip_state
*state
)
805 struct trace_context
*tr_ctx
= trace_context(_pipe
);
806 struct pipe_context
*pipe
= tr_ctx
->pipe
;
808 trace_dump_call_begin("pipe_context", "set_clip_state");
810 trace_dump_arg(ptr
, pipe
);
811 trace_dump_arg(clip_state
, state
);
813 pipe
->set_clip_state(pipe
, state
);;
815 trace_dump_call_end();
820 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
821 uint shader
, uint index
,
822 const struct pipe_constant_buffer
*buffer
)
824 struct trace_context
*tr_ctx
= trace_context(_pipe
);
825 struct pipe_context
*pipe
= tr_ctx
->pipe
;
828 trace_screen_user_buffer_update(_pipe
->screen
, buffer
->buffer
);
830 trace_dump_call_begin("pipe_context", "set_constant_buffer");
832 trace_dump_arg(ptr
, pipe
);
833 trace_dump_arg(uint
, shader
);
834 trace_dump_arg(uint
, index
);
835 trace_dump_arg(constant_buffer
, buffer
);
838 struct pipe_constant_buffer _buffer
;
839 _buffer
.buffer
= trace_buffer_unwrap(tr_ctx
, buffer
->buffer
);
840 pipe
->set_constant_buffer(pipe
, shader
, index
, &_buffer
);
842 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
845 trace_dump_call_end();
850 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
851 const struct pipe_framebuffer_state
*state
)
853 struct trace_context
*tr_ctx
= trace_context(_pipe
);
854 struct pipe_context
*pipe
= tr_ctx
->pipe
;
855 struct pipe_framebuffer_state unwrapped_state
;
859 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
860 for (i
= 0; i
< state
->nr_cbufs
; i
++)
862 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
864 tr_ctx
->curr
.cbufs
[i
] = NULL
;
866 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
868 tr_ctx
->curr
.zsbuf
= NULL
;
871 /* Unwrap the input state */
872 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
873 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
874 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
875 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
876 unwrapped_state
.cbufs
[i
] = NULL
;
877 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
878 state
= &unwrapped_state
;
880 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
882 trace_dump_arg(ptr
, pipe
);
883 trace_dump_arg(framebuffer_state
, state
);
885 pipe
->set_framebuffer_state(pipe
, state
);;
887 trace_dump_call_end();
892 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
893 const struct pipe_poly_stipple
*state
)
895 struct trace_context
*tr_ctx
= trace_context(_pipe
);
896 struct pipe_context
*pipe
= tr_ctx
->pipe
;
898 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
900 trace_dump_arg(ptr
, pipe
);
901 trace_dump_arg(poly_stipple
, state
);
903 pipe
->set_polygon_stipple(pipe
, state
);;
905 trace_dump_call_end();
910 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
911 const struct pipe_scissor_state
*state
)
913 struct trace_context
*tr_ctx
= trace_context(_pipe
);
914 struct pipe_context
*pipe
= tr_ctx
->pipe
;
916 trace_dump_call_begin("pipe_context", "set_scissor_state");
918 trace_dump_arg(ptr
, pipe
);
919 trace_dump_arg(scissor_state
, state
);
921 pipe
->set_scissor_state(pipe
, state
);;
923 trace_dump_call_end();
928 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
929 const struct pipe_viewport_state
*state
)
931 struct trace_context
*tr_ctx
= trace_context(_pipe
);
932 struct pipe_context
*pipe
= tr_ctx
->pipe
;
934 trace_dump_call_begin("pipe_context", "set_viewport_state");
936 trace_dump_arg(ptr
, pipe
);
937 trace_dump_arg(viewport_state
, state
);
939 pipe
->set_viewport_state(pipe
, state
);;
941 trace_dump_call_end();
946 trace_context_set_sampler_textures(struct pipe_context
*_pipe
,
947 unsigned num_textures
,
948 struct pipe_texture
**textures
)
950 struct trace_context
*tr_ctx
= trace_context(_pipe
);
951 struct trace_texture
*tr_tex
;
952 struct pipe_context
*pipe
= tr_ctx
->pipe
;
953 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
956 tr_ctx
->curr
.num_texs
= num_textures
;
957 for(i
= 0; i
< num_textures
; ++i
) {
958 tr_tex
= trace_texture(textures
[i
]);
959 tr_ctx
->curr
.tex
[i
] = tr_tex
;
960 unwrapped_textures
[i
] = tr_tex
? tr_tex
->texture
: NULL
;
962 textures
= unwrapped_textures
;
964 trace_dump_call_begin("pipe_context", "set_sampler_textures");
966 trace_dump_arg(ptr
, pipe
);
967 trace_dump_arg(uint
, num_textures
);
968 trace_dump_arg_array(ptr
, textures
, num_textures
);
970 pipe
->set_sampler_textures(pipe
, num_textures
, textures
);;
972 trace_dump_call_end();
977 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
978 unsigned num_buffers
,
979 const struct pipe_vertex_buffer
*buffers
)
981 struct trace_context
*tr_ctx
= trace_context(_pipe
);
982 struct pipe_context
*pipe
= tr_ctx
->pipe
;
985 for(i
= 0; i
< num_buffers
; ++i
)
986 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
988 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
990 trace_dump_arg(ptr
, pipe
);
991 trace_dump_arg(uint
, num_buffers
);
993 trace_dump_arg_begin("buffers");
994 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
995 trace_dump_arg_end();
998 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
999 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
1000 for (i
= 0; i
< num_buffers
; i
++)
1001 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
1002 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
1005 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
1008 trace_dump_call_end();
1013 trace_context_set_vertex_elements(struct pipe_context
*_pipe
,
1014 unsigned num_elements
,
1015 const struct pipe_vertex_element
*elements
)
1017 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1018 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1020 trace_dump_call_begin("pipe_context", "set_vertex_elements");
1022 trace_dump_arg(ptr
, pipe
);
1023 trace_dump_arg(uint
, num_elements
);
1025 trace_dump_arg_begin("elements");
1026 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
1027 trace_dump_arg_end();
1029 pipe
->set_vertex_elements(pipe
, num_elements
, elements
);;
1031 trace_dump_call_end();
1036 trace_context_surface_copy(struct pipe_context
*_pipe
,
1037 struct pipe_surface
*dest
,
1038 unsigned destx
, unsigned desty
,
1039 struct pipe_surface
*src
,
1040 unsigned srcx
, unsigned srcy
,
1041 unsigned width
, unsigned height
)
1043 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1044 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1046 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1047 src
= trace_surface_unwrap(tr_ctx
, src
);
1049 trace_dump_call_begin("pipe_context", "surface_copy");
1051 trace_dump_arg(ptr
, pipe
);
1052 trace_dump_arg(ptr
, dest
);
1053 trace_dump_arg(uint
, destx
);
1054 trace_dump_arg(uint
, desty
);
1055 trace_dump_arg(ptr
, src
);
1056 trace_dump_arg(uint
, srcx
);
1057 trace_dump_arg(uint
, srcy
);
1058 trace_dump_arg(uint
, width
);
1059 trace_dump_arg(uint
, height
);
1061 pipe
->surface_copy(pipe
,
1063 src
, srcx
, srcy
, width
, height
);
1065 trace_dump_call_end();
1070 trace_context_surface_fill(struct pipe_context
*_pipe
,
1071 struct pipe_surface
*dst
,
1072 unsigned dstx
, unsigned dsty
,
1073 unsigned width
, unsigned height
,
1076 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1077 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1079 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1081 trace_dump_call_begin("pipe_context", "surface_fill");
1083 trace_dump_arg(ptr
, pipe
);
1084 trace_dump_arg(ptr
, dst
);
1085 trace_dump_arg(uint
, dstx
);
1086 trace_dump_arg(uint
, dsty
);
1087 trace_dump_arg(uint
, width
);
1088 trace_dump_arg(uint
, height
);
1090 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);;
1092 trace_dump_call_end();
1097 trace_context_clear(struct pipe_context
*_pipe
,
1103 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1104 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1106 trace_dump_call_begin("pipe_context", "clear");
1108 trace_dump_arg(ptr
, pipe
);
1109 trace_dump_arg(uint
, buffers
);
1110 trace_dump_arg_array(float, rgba
, 4);
1111 trace_dump_arg(float, depth
);
1112 trace_dump_arg(uint
, stencil
);
1114 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1116 trace_dump_call_end();
1121 trace_context_flush(struct pipe_context
*_pipe
,
1123 struct pipe_fence_handle
**fence
)
1125 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1126 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1128 trace_dump_call_begin("pipe_context", "flush");
1130 trace_dump_arg(ptr
, pipe
);
1131 trace_dump_arg(uint
, flags
);
1133 pipe
->flush(pipe
, flags
, fence
);;
1136 trace_dump_ret(ptr
, *fence
);
1138 trace_dump_call_end();
1143 trace_context_destroy(struct pipe_context
*_pipe
)
1145 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1146 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1147 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1149 trace_dump_call_begin("pipe_context", "destroy");
1150 trace_dump_arg(ptr
, pipe
);
1151 trace_dump_call_end();
1153 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1155 pipe
->destroy(pipe
);
1161 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1162 struct pipe_texture
*_texture
,
1163 unsigned face
, unsigned level
)
1165 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1166 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1167 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1168 struct pipe_texture
*texture
= tr_tex
->texture
;
1169 unsigned int referenced
;
1171 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1172 trace_dump_arg(ptr
, pipe
);
1173 trace_dump_arg(ptr
, texture
);
1174 trace_dump_arg(uint
, face
);
1175 trace_dump_arg(uint
, level
);
1177 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1179 trace_dump_ret(uint
, referenced
);
1180 trace_dump_call_end();
1186 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1187 struct pipe_buffer
*_buf
)
1189 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1190 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1191 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1192 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1193 unsigned int referenced
;
1195 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1196 trace_dump_arg(ptr
, pipe
);
1197 trace_dump_arg(ptr
, buf
);
1199 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1201 trace_dump_ret(uint
, referenced
);
1202 trace_dump_call_end();
1207 static const struct debug_named_value rbug_blocker_flags
[] = {
1213 struct pipe_context
*
1214 trace_context_create(struct pipe_screen
*_screen
,
1215 struct pipe_context
*pipe
)
1217 struct trace_screen
*tr_scr
;
1218 struct trace_context
*tr_ctx
;
1219 struct pipe_screen
*screen
;
1224 if(!trace_enabled())
1227 tr_scr
= trace_screen(_screen
);
1228 screen
= tr_scr
->screen
;
1230 tr_ctx
= CALLOC_STRUCT(trace_context
);
1234 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1237 pipe_mutex_init(tr_ctx
->draw_mutex
);
1238 pipe_condvar_init(tr_ctx
->draw_cond
);
1239 pipe_mutex_init(tr_ctx
->list_mutex
);
1240 make_empty_list(&tr_ctx
->shaders
);
1242 tr_ctx
->base
.winsys
= _screen
->winsys
;
1243 tr_ctx
->base
.screen
= _screen
;
1244 tr_ctx
->base
.destroy
= trace_context_destroy
;
1245 tr_ctx
->base
.set_edgeflags
= trace_context_set_edgeflags
;
1246 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1247 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1248 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1249 tr_ctx
->base
.create_query
= trace_context_create_query
;
1250 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1251 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1252 tr_ctx
->base
.end_query
= trace_context_end_query
;
1253 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1254 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1255 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1256 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1257 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1258 tr_ctx
->base
.bind_sampler_states
= trace_context_bind_sampler_states
;
1259 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1260 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1261 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1262 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1263 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1264 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1265 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1266 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1267 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1268 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1269 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1270 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1271 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1272 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1273 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1274 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1275 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1276 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1277 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1278 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1279 tr_ctx
->base
.set_sampler_textures
= trace_context_set_sampler_textures
;
1280 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1281 tr_ctx
->base
.set_vertex_elements
= trace_context_set_vertex_elements
;
1282 if (pipe
->surface_copy
)
1283 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1284 if (pipe
->surface_fill
)
1285 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1286 tr_ctx
->base
.clear
= trace_context_clear
;
1287 tr_ctx
->base
.flush
= trace_context_flush
;
1288 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1289 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1291 tr_ctx
->pipe
= pipe
;
1293 trace_dump_call_begin("", "pipe_context_create");
1294 trace_dump_arg(ptr
, screen
);
1295 trace_dump_ret(ptr
, pipe
);
1296 trace_dump_call_end();
1298 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1300 return &tr_ctx
->base
;