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
)
119 pipe_mutex_lock(tr_ctx
->draw_mutex
);
121 if (tr_ctx
->draw_blocker
& flag
) {
122 tr_ctx
->draw_blocked
|= flag
;
124 trace_rbug_notify_draw_blocked(tr_ctx
);
127 /* wait for rbug to clear the blocked flag */
128 while (tr_ctx
->draw_blocked
& flag
) {
129 tr_ctx
->draw_blocked
|= flag
;
130 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
131 /* TODO sleep or use conditional */
132 pipe_mutex_lock(tr_ctx
->draw_mutex
);
135 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
138 static INLINE boolean
139 trace_context_draw_arrays(struct pipe_context
*_pipe
,
140 unsigned mode
, unsigned start
, unsigned count
)
142 struct trace_context
*tr_ctx
= trace_context(_pipe
);
143 struct pipe_context
*pipe
= tr_ctx
->pipe
;
146 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
149 trace_context_draw_block(tr_ctx
, 1);
151 trace_dump_call_begin("pipe_context", "draw_arrays");
153 trace_dump_arg(ptr
, pipe
);
154 trace_dump_arg(uint
, mode
);
155 trace_dump_arg(uint
, start
);
156 trace_dump_arg(uint
, count
);
158 result
= pipe
->draw_arrays(pipe
, mode
, start
, count
);;
160 trace_dump_ret(bool, result
);
162 trace_dump_call_end();
164 trace_context_draw_block(tr_ctx
, 2);
170 static INLINE boolean
171 trace_context_draw_elements(struct pipe_context
*_pipe
,
172 struct pipe_buffer
*_indexBuffer
,
174 unsigned mode
, unsigned start
, unsigned count
)
176 struct trace_context
*tr_ctx
= trace_context(_pipe
);
177 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
178 struct pipe_context
*pipe
= tr_ctx
->pipe
;
179 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
182 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
185 trace_context_draw_block(tr_ctx
, 1);
187 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
189 trace_dump_call_begin("pipe_context", "draw_elements");
191 trace_dump_arg(ptr
, pipe
);
192 trace_dump_arg(ptr
, indexBuffer
);
193 trace_dump_arg(uint
, indexSize
);
194 trace_dump_arg(uint
, mode
);
195 trace_dump_arg(uint
, start
);
196 trace_dump_arg(uint
, count
);
198 result
= pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);;
200 trace_dump_ret(bool, result
);
202 trace_dump_call_end();
204 trace_context_draw_block(tr_ctx
, 2);
210 static INLINE boolean
211 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
212 struct pipe_buffer
*_indexBuffer
,
220 struct trace_context
*tr_ctx
= trace_context(_pipe
);
221 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
222 struct pipe_context
*pipe
= tr_ctx
->pipe
;
223 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
226 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
229 trace_context_draw_block(tr_ctx
, 1);
231 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
233 trace_dump_call_begin("pipe_context", "draw_range_elements");
235 trace_dump_arg(ptr
, pipe
);
236 trace_dump_arg(ptr
, indexBuffer
);
237 trace_dump_arg(uint
, indexSize
);
238 trace_dump_arg(uint
, minIndex
);
239 trace_dump_arg(uint
, maxIndex
);
240 trace_dump_arg(uint
, mode
);
241 trace_dump_arg(uint
, start
);
242 trace_dump_arg(uint
, count
);
244 result
= pipe
->draw_range_elements(pipe
,
246 indexSize
, minIndex
, maxIndex
,
249 trace_dump_ret(bool, result
);
251 trace_dump_call_end();
253 trace_context_draw_block(tr_ctx
, 2);
259 static INLINE
struct pipe_query
*
260 trace_context_create_query(struct pipe_context
*_pipe
,
263 struct trace_context
*tr_ctx
= trace_context(_pipe
);
264 struct pipe_context
*pipe
= tr_ctx
->pipe
;
265 struct pipe_query
*result
;
267 trace_dump_call_begin("pipe_context", "create_query");
269 trace_dump_arg(ptr
, pipe
);
270 trace_dump_arg(uint
, query_type
);
272 result
= pipe
->create_query(pipe
, query_type
);;
274 trace_dump_ret(ptr
, result
);
276 trace_dump_call_end();
283 trace_context_destroy_query(struct pipe_context
*_pipe
,
284 struct pipe_query
*query
)
286 struct trace_context
*tr_ctx
= trace_context(_pipe
);
287 struct pipe_context
*pipe
= tr_ctx
->pipe
;
289 trace_dump_call_begin("pipe_context", "destroy_query");
291 trace_dump_arg(ptr
, pipe
);
292 trace_dump_arg(ptr
, query
);
294 pipe
->destroy_query(pipe
, query
);;
296 trace_dump_call_end();
301 trace_context_begin_query(struct pipe_context
*_pipe
,
302 struct pipe_query
*query
)
304 struct trace_context
*tr_ctx
= trace_context(_pipe
);
305 struct pipe_context
*pipe
= tr_ctx
->pipe
;
307 trace_dump_call_begin("pipe_context", "begin_query");
309 trace_dump_arg(ptr
, pipe
);
310 trace_dump_arg(ptr
, query
);
312 pipe
->begin_query(pipe
, query
);;
314 trace_dump_call_end();
319 trace_context_end_query(struct pipe_context
*_pipe
,
320 struct pipe_query
*query
)
322 struct trace_context
*tr_ctx
= trace_context(_pipe
);
323 struct pipe_context
*pipe
= tr_ctx
->pipe
;
325 trace_dump_call_begin("pipe_context", "end_query");
327 trace_dump_arg(ptr
, pipe
);
328 trace_dump_arg(ptr
, query
);
330 pipe
->end_query(pipe
, query
);
332 trace_dump_call_end();
336 static INLINE boolean
337 trace_context_get_query_result(struct pipe_context
*_pipe
,
338 struct pipe_query
*query
,
342 struct trace_context
*tr_ctx
= trace_context(_pipe
);
343 struct pipe_context
*pipe
= tr_ctx
->pipe
;
347 trace_dump_call_begin("pipe_context", "get_query_result");
349 trace_dump_arg(ptr
, pipe
);
351 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);;
354 trace_dump_arg(uint
, result
);
355 trace_dump_ret(bool, _result
);
357 trace_dump_call_end();
364 trace_context_create_blend_state(struct pipe_context
*_pipe
,
365 const struct pipe_blend_state
*state
)
367 struct trace_context
*tr_ctx
= trace_context(_pipe
);
368 struct pipe_context
*pipe
= tr_ctx
->pipe
;
371 trace_dump_call_begin("pipe_context", "create_blend_state");
373 trace_dump_arg(ptr
, pipe
);
374 trace_dump_arg(blend_state
, state
);
376 result
= pipe
->create_blend_state(pipe
, state
);;
378 trace_dump_ret(ptr
, result
);
380 trace_dump_call_end();
387 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
390 struct trace_context
*tr_ctx
= trace_context(_pipe
);
391 struct pipe_context
*pipe
= tr_ctx
->pipe
;
393 trace_dump_call_begin("pipe_context", "bind_blend_state");
395 trace_dump_arg(ptr
, pipe
);
396 trace_dump_arg(ptr
, state
);
398 pipe
->bind_blend_state(pipe
, state
);;
400 trace_dump_call_end();
405 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
408 struct trace_context
*tr_ctx
= trace_context(_pipe
);
409 struct pipe_context
*pipe
= tr_ctx
->pipe
;
411 trace_dump_call_begin("pipe_context", "delete_blend_state");
413 trace_dump_arg(ptr
, pipe
);
414 trace_dump_arg(ptr
, state
);
416 pipe
->delete_blend_state(pipe
, state
);;
418 trace_dump_call_end();
423 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
424 const struct pipe_sampler_state
*state
)
426 struct trace_context
*tr_ctx
= trace_context(_pipe
);
427 struct pipe_context
*pipe
= tr_ctx
->pipe
;
430 trace_dump_call_begin("pipe_context", "create_sampler_state");
432 trace_dump_arg(ptr
, pipe
);
433 trace_dump_arg(sampler_state
, state
);
435 result
= pipe
->create_sampler_state(pipe
, state
);;
437 trace_dump_ret(ptr
, result
);
439 trace_dump_call_end();
446 trace_context_bind_sampler_states(struct pipe_context
*_pipe
,
447 unsigned num_states
, void **states
)
449 struct trace_context
*tr_ctx
= trace_context(_pipe
);
450 struct pipe_context
*pipe
= tr_ctx
->pipe
;
452 trace_dump_call_begin("pipe_context", "bind_sampler_states");
454 trace_dump_arg(ptr
, pipe
);
455 trace_dump_arg(uint
, num_states
);
456 trace_dump_arg_array(ptr
, states
, num_states
);
458 pipe
->bind_sampler_states(pipe
, num_states
, states
);;
460 trace_dump_call_end();
465 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
468 struct trace_context
*tr_ctx
= trace_context(_pipe
);
469 struct pipe_context
*pipe
= tr_ctx
->pipe
;
471 trace_dump_call_begin("pipe_context", "delete_sampler_state");
473 trace_dump_arg(ptr
, pipe
);
474 trace_dump_arg(ptr
, state
);
476 pipe
->delete_sampler_state(pipe
, state
);;
478 trace_dump_call_end();
483 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
484 const struct pipe_rasterizer_state
*state
)
486 struct trace_context
*tr_ctx
= trace_context(_pipe
);
487 struct pipe_context
*pipe
= tr_ctx
->pipe
;
490 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
492 trace_dump_arg(ptr
, pipe
);
493 trace_dump_arg(rasterizer_state
, state
);
495 result
= pipe
->create_rasterizer_state(pipe
, state
);;
497 trace_dump_ret(ptr
, result
);
499 trace_dump_call_end();
506 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
509 struct trace_context
*tr_ctx
= trace_context(_pipe
);
510 struct pipe_context
*pipe
= tr_ctx
->pipe
;
512 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
514 trace_dump_arg(ptr
, pipe
);
515 trace_dump_arg(ptr
, state
);
517 pipe
->bind_rasterizer_state(pipe
, state
);;
519 trace_dump_call_end();
524 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
527 struct trace_context
*tr_ctx
= trace_context(_pipe
);
528 struct pipe_context
*pipe
= tr_ctx
->pipe
;
530 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
532 trace_dump_arg(ptr
, pipe
);
533 trace_dump_arg(ptr
, state
);
535 pipe
->delete_rasterizer_state(pipe
, state
);;
537 trace_dump_call_end();
542 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
543 const struct pipe_depth_stencil_alpha_state
*state
)
545 struct trace_context
*tr_ctx
= trace_context(_pipe
);
546 struct pipe_context
*pipe
= tr_ctx
->pipe
;
549 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
551 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);;
553 trace_dump_arg(ptr
, pipe
);
554 trace_dump_arg(depth_stencil_alpha_state
, state
);
556 trace_dump_ret(ptr
, result
);
558 trace_dump_call_end();
565 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
568 struct trace_context
*tr_ctx
= trace_context(_pipe
);
569 struct pipe_context
*pipe
= tr_ctx
->pipe
;
571 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
573 trace_dump_arg(ptr
, pipe
);
574 trace_dump_arg(ptr
, state
);
576 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);;
578 trace_dump_call_end();
583 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
586 struct trace_context
*tr_ctx
= trace_context(_pipe
);
587 struct pipe_context
*pipe
= tr_ctx
->pipe
;
589 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
591 trace_dump_arg(ptr
, pipe
);
592 trace_dump_arg(ptr
, state
);
594 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);;
596 trace_dump_call_end();
601 trace_context_create_fs_state(struct pipe_context
*_pipe
,
602 const struct pipe_shader_state
*state
)
604 struct trace_context
*tr_ctx
= trace_context(_pipe
);
605 struct pipe_context
*pipe
= tr_ctx
->pipe
;
608 trace_dump_call_begin("pipe_context", "create_fs_state");
610 trace_dump_arg(ptr
, pipe
);
611 trace_dump_arg(shader_state
, state
);
613 result
= pipe
->create_fs_state(pipe
, state
);;
615 trace_dump_ret(ptr
, result
);
617 trace_dump_call_end();
619 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
626 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
629 struct trace_context
*tr_ctx
= trace_context(_pipe
);
630 struct trace_shader
*tr_shdr
= trace_shader(_state
);
631 struct pipe_context
*pipe
= tr_ctx
->pipe
;
632 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
634 trace_dump_call_begin("pipe_context", "bind_fs_state");
636 trace_dump_arg(ptr
, pipe
);
637 trace_dump_arg(ptr
, state
);
639 tr_ctx
->curr
.fs
= tr_shdr
;
641 if (tr_shdr
&& tr_shdr
->replaced
)
642 state
= tr_shdr
->replaced
;
644 pipe
->bind_fs_state(pipe
, state
);
646 trace_dump_call_end();
651 trace_context_delete_fs_state(struct pipe_context
*_pipe
,
654 struct trace_context
*tr_ctx
= trace_context(_pipe
);
655 struct trace_shader
*tr_shdr
= trace_shader(_state
);
656 struct pipe_context
*pipe
= tr_ctx
->pipe
;
657 void *state
= tr_shdr
->state
;
659 trace_dump_call_begin("pipe_context", "delete_fs_state");
661 trace_dump_arg(ptr
, pipe
);
662 trace_dump_arg(ptr
, state
);
664 pipe
->delete_fs_state(pipe
, state
);
666 trace_dump_call_end();
668 trace_shader_destroy(tr_ctx
, tr_shdr
);
673 trace_context_create_vs_state(struct pipe_context
*_pipe
,
674 const struct pipe_shader_state
*state
)
676 struct trace_context
*tr_ctx
= trace_context(_pipe
);
677 struct pipe_context
*pipe
= tr_ctx
->pipe
;
680 trace_dump_call_begin("pipe_context", "create_vs_state");
682 trace_dump_arg(ptr
, pipe
);
683 trace_dump_arg(shader_state
, state
);
685 result
= pipe
->create_vs_state(pipe
, state
);
687 trace_dump_ret(ptr
, result
);
689 trace_dump_call_end();
691 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
698 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
701 struct trace_context
*tr_ctx
= trace_context(_pipe
);
702 struct trace_shader
*tr_shdr
= trace_shader(_state
);
703 struct pipe_context
*pipe
= tr_ctx
->pipe
;
704 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
706 trace_dump_call_begin("pipe_context", "bind_vs_state");
708 trace_dump_arg(ptr
, pipe
);
709 trace_dump_arg(ptr
, state
);
711 tr_ctx
->curr
.vs
= tr_shdr
;
713 if (tr_shdr
&& tr_shdr
->replaced
)
714 state
= tr_shdr
->replaced
;
716 pipe
->bind_vs_state(pipe
, state
);;
718 trace_dump_call_end();
723 trace_context_delete_vs_state(struct pipe_context
*_pipe
,
726 struct trace_context
*tr_ctx
= trace_context(_pipe
);
727 struct trace_shader
*tr_shdr
= trace_shader(_state
);
728 struct pipe_context
*pipe
= tr_ctx
->pipe
;
729 void *state
= tr_shdr
->state
;
731 trace_dump_call_begin("pipe_context", "delete_vs_state");
733 trace_dump_arg(ptr
, pipe
);
734 trace_dump_arg(ptr
, state
);
736 pipe
->delete_vs_state(pipe
, state
);;
738 trace_dump_call_end();
740 trace_shader_destroy(tr_ctx
, tr_shdr
);
745 trace_context_set_blend_color(struct pipe_context
*_pipe
,
746 const struct pipe_blend_color
*state
)
748 struct trace_context
*tr_ctx
= trace_context(_pipe
);
749 struct pipe_context
*pipe
= tr_ctx
->pipe
;
751 trace_dump_call_begin("pipe_context", "set_blend_color");
753 trace_dump_arg(ptr
, pipe
);
754 trace_dump_arg(blend_color
, state
);
756 pipe
->set_blend_color(pipe
, state
);;
758 trace_dump_call_end();
763 trace_context_set_clip_state(struct pipe_context
*_pipe
,
764 const struct pipe_clip_state
*state
)
766 struct trace_context
*tr_ctx
= trace_context(_pipe
);
767 struct pipe_context
*pipe
= tr_ctx
->pipe
;
769 trace_dump_call_begin("pipe_context", "set_clip_state");
771 trace_dump_arg(ptr
, pipe
);
772 trace_dump_arg(clip_state
, state
);
774 pipe
->set_clip_state(pipe
, state
);;
776 trace_dump_call_end();
781 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
782 uint shader
, uint index
,
783 const struct pipe_constant_buffer
*buffer
)
785 struct trace_context
*tr_ctx
= trace_context(_pipe
);
786 struct pipe_context
*pipe
= tr_ctx
->pipe
;
789 trace_screen_user_buffer_update(_pipe
->screen
, buffer
->buffer
);
791 trace_dump_call_begin("pipe_context", "set_constant_buffer");
793 trace_dump_arg(ptr
, pipe
);
794 trace_dump_arg(uint
, shader
);
795 trace_dump_arg(uint
, index
);
796 trace_dump_arg(constant_buffer
, buffer
);
799 struct pipe_constant_buffer _buffer
;
800 _buffer
.buffer
= trace_buffer_unwrap(tr_ctx
, buffer
->buffer
);
801 pipe
->set_constant_buffer(pipe
, shader
, index
, &_buffer
);
803 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
806 trace_dump_call_end();
811 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
812 const struct pipe_framebuffer_state
*state
)
814 struct trace_context
*tr_ctx
= trace_context(_pipe
);
815 struct pipe_context
*pipe
= tr_ctx
->pipe
;
816 struct pipe_framebuffer_state unwrapped_state
;
820 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
821 for (i
= 0; i
< state
->nr_cbufs
; i
++)
823 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
825 tr_ctx
->curr
.cbufs
[i
] = NULL
;
827 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
829 tr_ctx
->curr
.zsbuf
= NULL
;
832 /* Unwrap the input state */
833 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
834 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
835 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
836 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
837 unwrapped_state
.cbufs
[i
] = NULL
;
838 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
839 state
= &unwrapped_state
;
841 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
843 trace_dump_arg(ptr
, pipe
);
844 trace_dump_arg(framebuffer_state
, state
);
846 pipe
->set_framebuffer_state(pipe
, state
);;
848 trace_dump_call_end();
853 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
854 const struct pipe_poly_stipple
*state
)
856 struct trace_context
*tr_ctx
= trace_context(_pipe
);
857 struct pipe_context
*pipe
= tr_ctx
->pipe
;
859 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
861 trace_dump_arg(ptr
, pipe
);
862 trace_dump_arg(poly_stipple
, state
);
864 pipe
->set_polygon_stipple(pipe
, state
);;
866 trace_dump_call_end();
871 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
872 const struct pipe_scissor_state
*state
)
874 struct trace_context
*tr_ctx
= trace_context(_pipe
);
875 struct pipe_context
*pipe
= tr_ctx
->pipe
;
877 trace_dump_call_begin("pipe_context", "set_scissor_state");
879 trace_dump_arg(ptr
, pipe
);
880 trace_dump_arg(scissor_state
, state
);
882 pipe
->set_scissor_state(pipe
, state
);;
884 trace_dump_call_end();
889 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
890 const struct pipe_viewport_state
*state
)
892 struct trace_context
*tr_ctx
= trace_context(_pipe
);
893 struct pipe_context
*pipe
= tr_ctx
->pipe
;
895 trace_dump_call_begin("pipe_context", "set_viewport_state");
897 trace_dump_arg(ptr
, pipe
);
898 trace_dump_arg(viewport_state
, state
);
900 pipe
->set_viewport_state(pipe
, state
);;
902 trace_dump_call_end();
907 trace_context_set_sampler_textures(struct pipe_context
*_pipe
,
908 unsigned num_textures
,
909 struct pipe_texture
**textures
)
911 struct trace_context
*tr_ctx
= trace_context(_pipe
);
912 struct pipe_context
*pipe
= tr_ctx
->pipe
;
913 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
916 for(i
= 0; i
< num_textures
; ++i
)
917 unwrapped_textures
[i
] = trace_texture_unwrap(tr_ctx
, textures
[i
]);
918 textures
= unwrapped_textures
;
920 trace_dump_call_begin("pipe_context", "set_sampler_textures");
922 trace_dump_arg(ptr
, pipe
);
923 trace_dump_arg(uint
, num_textures
);
924 trace_dump_arg_array(ptr
, textures
, num_textures
);
926 pipe
->set_sampler_textures(pipe
, num_textures
, textures
);;
928 trace_dump_call_end();
933 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
934 unsigned num_buffers
,
935 const struct pipe_vertex_buffer
*buffers
)
937 struct trace_context
*tr_ctx
= trace_context(_pipe
);
938 struct pipe_context
*pipe
= tr_ctx
->pipe
;
941 for(i
= 0; i
< num_buffers
; ++i
)
942 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
944 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
946 trace_dump_arg(ptr
, pipe
);
947 trace_dump_arg(uint
, num_buffers
);
949 trace_dump_arg_begin("buffers");
950 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
951 trace_dump_arg_end();
954 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
955 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
956 for (i
= 0; i
< num_buffers
; i
++)
957 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
958 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
961 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
964 trace_dump_call_end();
969 trace_context_set_vertex_elements(struct pipe_context
*_pipe
,
970 unsigned num_elements
,
971 const struct pipe_vertex_element
*elements
)
973 struct trace_context
*tr_ctx
= trace_context(_pipe
);
974 struct pipe_context
*pipe
= tr_ctx
->pipe
;
976 trace_dump_call_begin("pipe_context", "set_vertex_elements");
978 trace_dump_arg(ptr
, pipe
);
979 trace_dump_arg(uint
, num_elements
);
981 trace_dump_arg_begin("elements");
982 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
983 trace_dump_arg_end();
985 pipe
->set_vertex_elements(pipe
, num_elements
, elements
);;
987 trace_dump_call_end();
992 trace_context_surface_copy(struct pipe_context
*_pipe
,
993 struct pipe_surface
*dest
,
994 unsigned destx
, unsigned desty
,
995 struct pipe_surface
*src
,
996 unsigned srcx
, unsigned srcy
,
997 unsigned width
, unsigned height
)
999 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1000 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1002 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1003 src
= trace_surface_unwrap(tr_ctx
, src
);
1005 trace_dump_call_begin("pipe_context", "surface_copy");
1007 trace_dump_arg(ptr
, pipe
);
1008 trace_dump_arg(ptr
, dest
);
1009 trace_dump_arg(uint
, destx
);
1010 trace_dump_arg(uint
, desty
);
1011 trace_dump_arg(ptr
, src
);
1012 trace_dump_arg(uint
, srcx
);
1013 trace_dump_arg(uint
, srcy
);
1014 trace_dump_arg(uint
, width
);
1015 trace_dump_arg(uint
, height
);
1017 pipe
->surface_copy(pipe
,
1019 src
, srcx
, srcy
, width
, height
);
1021 trace_dump_call_end();
1026 trace_context_surface_fill(struct pipe_context
*_pipe
,
1027 struct pipe_surface
*dst
,
1028 unsigned dstx
, unsigned dsty
,
1029 unsigned width
, unsigned height
,
1032 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1033 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1035 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1037 trace_dump_call_begin("pipe_context", "surface_fill");
1039 trace_dump_arg(ptr
, pipe
);
1040 trace_dump_arg(ptr
, dst
);
1041 trace_dump_arg(uint
, dstx
);
1042 trace_dump_arg(uint
, dsty
);
1043 trace_dump_arg(uint
, width
);
1044 trace_dump_arg(uint
, height
);
1046 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);;
1048 trace_dump_call_end();
1053 trace_context_clear(struct pipe_context
*_pipe
,
1059 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1060 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1062 trace_dump_call_begin("pipe_context", "clear");
1064 trace_dump_arg(ptr
, pipe
);
1065 trace_dump_arg(uint
, buffers
);
1066 trace_dump_arg_array(float, rgba
, 4);
1067 trace_dump_arg(float, depth
);
1068 trace_dump_arg(uint
, stencil
);
1070 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1072 trace_dump_call_end();
1077 trace_context_flush(struct pipe_context
*_pipe
,
1079 struct pipe_fence_handle
**fence
)
1081 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1082 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1084 trace_dump_call_begin("pipe_context", "flush");
1086 trace_dump_arg(ptr
, pipe
);
1087 trace_dump_arg(uint
, flags
);
1089 pipe
->flush(pipe
, flags
, fence
);;
1092 trace_dump_ret(ptr
, *fence
);
1094 trace_dump_call_end();
1099 trace_context_destroy(struct pipe_context
*_pipe
)
1101 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1102 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1103 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1105 trace_dump_call_begin("pipe_context", "destroy");
1106 trace_dump_arg(ptr
, pipe
);
1107 trace_dump_call_end();
1109 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1111 pipe
->destroy(pipe
);
1117 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1118 struct pipe_texture
*_texture
,
1119 unsigned face
, unsigned level
)
1121 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1122 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1123 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1124 struct pipe_texture
*texture
= tr_tex
->texture
;
1125 unsigned int referenced
;
1127 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1128 trace_dump_arg(ptr
, pipe
);
1129 trace_dump_arg(ptr
, texture
);
1130 trace_dump_arg(uint
, face
);
1131 trace_dump_arg(uint
, level
);
1133 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1135 trace_dump_ret(uint
, referenced
);
1136 trace_dump_call_end();
1142 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1143 struct pipe_buffer
*_buf
)
1145 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1146 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1147 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1148 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1149 unsigned int referenced
;
1151 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1152 trace_dump_arg(ptr
, pipe
);
1153 trace_dump_arg(ptr
, buf
);
1155 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1157 trace_dump_ret(uint
, referenced
);
1158 trace_dump_call_end();
1163 static const struct debug_named_value rbug_blocker_flags
[] = {
1169 struct pipe_context
*
1170 trace_context_create(struct pipe_screen
*_screen
,
1171 struct pipe_context
*pipe
)
1173 struct trace_screen
*tr_scr
;
1174 struct trace_context
*tr_ctx
;
1175 struct pipe_screen
*screen
;
1180 if(!trace_enabled())
1183 tr_scr
= trace_screen(_screen
);
1184 screen
= tr_scr
->screen
;
1186 tr_ctx
= CALLOC_STRUCT(trace_context
);
1190 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1193 pipe_mutex_init(tr_ctx
->draw_mutex
);
1194 pipe_mutex_init(tr_ctx
->list_mutex
);
1195 make_empty_list(&tr_ctx
->shaders
);
1197 tr_ctx
->base
.winsys
= _screen
->winsys
;
1198 tr_ctx
->base
.screen
= _screen
;
1199 tr_ctx
->base
.destroy
= trace_context_destroy
;
1200 tr_ctx
->base
.set_edgeflags
= trace_context_set_edgeflags
;
1201 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1202 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1203 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1204 tr_ctx
->base
.create_query
= trace_context_create_query
;
1205 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1206 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1207 tr_ctx
->base
.end_query
= trace_context_end_query
;
1208 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1209 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1210 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1211 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1212 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1213 tr_ctx
->base
.bind_sampler_states
= trace_context_bind_sampler_states
;
1214 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1215 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1216 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1217 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1218 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1219 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1220 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1221 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1222 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1223 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1224 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1225 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1226 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1227 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1228 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1229 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1230 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1231 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1232 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1233 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1234 tr_ctx
->base
.set_sampler_textures
= trace_context_set_sampler_textures
;
1235 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1236 tr_ctx
->base
.set_vertex_elements
= trace_context_set_vertex_elements
;
1237 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1238 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1239 tr_ctx
->base
.clear
= trace_context_clear
;
1240 tr_ctx
->base
.flush
= trace_context_flush
;
1241 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1242 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1244 tr_ctx
->pipe
= pipe
;
1246 trace_dump_call_begin("", "pipe_context_create");
1247 trace_dump_arg(ptr
, screen
);
1248 trace_dump_ret(ptr
, pipe
);
1249 trace_dump_call_end();
1251 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1253 return &tr_ctx
->base
;