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 #ifdef PIPE_THREAD_HAVE_CONDVAR
131 pipe_condvar_wait(tr_ctx
->draw_cond
, tr_ctx
->draw_mutex
);
133 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
134 /* TODO sleep or use conditional */
135 pipe_mutex_lock(tr_ctx
->draw_mutex
);
139 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
142 static INLINE boolean
143 trace_context_draw_arrays(struct pipe_context
*_pipe
,
144 unsigned mode
, unsigned start
, unsigned count
)
146 struct trace_context
*tr_ctx
= trace_context(_pipe
);
147 struct pipe_context
*pipe
= tr_ctx
->pipe
;
150 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
153 trace_context_draw_block(tr_ctx
, 1);
155 trace_dump_call_begin("pipe_context", "draw_arrays");
157 trace_dump_arg(ptr
, pipe
);
158 trace_dump_arg(uint
, mode
);
159 trace_dump_arg(uint
, start
);
160 trace_dump_arg(uint
, count
);
162 result
= pipe
->draw_arrays(pipe
, mode
, start
, count
);;
164 trace_dump_ret(bool, result
);
166 trace_dump_call_end();
168 trace_context_draw_block(tr_ctx
, 2);
174 static INLINE boolean
175 trace_context_draw_elements(struct pipe_context
*_pipe
,
176 struct pipe_buffer
*_indexBuffer
,
178 unsigned mode
, unsigned start
, unsigned count
)
180 struct trace_context
*tr_ctx
= trace_context(_pipe
);
181 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
182 struct pipe_context
*pipe
= tr_ctx
->pipe
;
183 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
186 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
189 trace_context_draw_block(tr_ctx
, 1);
191 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
193 trace_dump_call_begin("pipe_context", "draw_elements");
195 trace_dump_arg(ptr
, pipe
);
196 trace_dump_arg(ptr
, indexBuffer
);
197 trace_dump_arg(uint
, indexSize
);
198 trace_dump_arg(uint
, mode
);
199 trace_dump_arg(uint
, start
);
200 trace_dump_arg(uint
, count
);
202 result
= pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);;
204 trace_dump_ret(bool, result
);
206 trace_dump_call_end();
208 trace_context_draw_block(tr_ctx
, 2);
214 static INLINE boolean
215 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
216 struct pipe_buffer
*_indexBuffer
,
224 struct trace_context
*tr_ctx
= trace_context(_pipe
);
225 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
226 struct pipe_context
*pipe
= tr_ctx
->pipe
;
227 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
230 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
233 trace_context_draw_block(tr_ctx
, 1);
235 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
237 trace_dump_call_begin("pipe_context", "draw_range_elements");
239 trace_dump_arg(ptr
, pipe
);
240 trace_dump_arg(ptr
, indexBuffer
);
241 trace_dump_arg(uint
, indexSize
);
242 trace_dump_arg(uint
, minIndex
);
243 trace_dump_arg(uint
, maxIndex
);
244 trace_dump_arg(uint
, mode
);
245 trace_dump_arg(uint
, start
);
246 trace_dump_arg(uint
, count
);
248 result
= pipe
->draw_range_elements(pipe
,
250 indexSize
, minIndex
, maxIndex
,
253 trace_dump_ret(bool, result
);
255 trace_dump_call_end();
257 trace_context_draw_block(tr_ctx
, 2);
263 static INLINE
struct pipe_query
*
264 trace_context_create_query(struct pipe_context
*_pipe
,
267 struct trace_context
*tr_ctx
= trace_context(_pipe
);
268 struct pipe_context
*pipe
= tr_ctx
->pipe
;
269 struct pipe_query
*result
;
271 trace_dump_call_begin("pipe_context", "create_query");
273 trace_dump_arg(ptr
, pipe
);
274 trace_dump_arg(uint
, query_type
);
276 result
= pipe
->create_query(pipe
, query_type
);;
278 trace_dump_ret(ptr
, result
);
280 trace_dump_call_end();
287 trace_context_destroy_query(struct pipe_context
*_pipe
,
288 struct pipe_query
*query
)
290 struct trace_context
*tr_ctx
= trace_context(_pipe
);
291 struct pipe_context
*pipe
= tr_ctx
->pipe
;
293 trace_dump_call_begin("pipe_context", "destroy_query");
295 trace_dump_arg(ptr
, pipe
);
296 trace_dump_arg(ptr
, query
);
298 pipe
->destroy_query(pipe
, query
);;
300 trace_dump_call_end();
305 trace_context_begin_query(struct pipe_context
*_pipe
,
306 struct pipe_query
*query
)
308 struct trace_context
*tr_ctx
= trace_context(_pipe
);
309 struct pipe_context
*pipe
= tr_ctx
->pipe
;
311 trace_dump_call_begin("pipe_context", "begin_query");
313 trace_dump_arg(ptr
, pipe
);
314 trace_dump_arg(ptr
, query
);
316 pipe
->begin_query(pipe
, query
);;
318 trace_dump_call_end();
323 trace_context_end_query(struct pipe_context
*_pipe
,
324 struct pipe_query
*query
)
326 struct trace_context
*tr_ctx
= trace_context(_pipe
);
327 struct pipe_context
*pipe
= tr_ctx
->pipe
;
329 trace_dump_call_begin("pipe_context", "end_query");
331 trace_dump_arg(ptr
, pipe
);
332 trace_dump_arg(ptr
, query
);
334 pipe
->end_query(pipe
, query
);
336 trace_dump_call_end();
340 static INLINE boolean
341 trace_context_get_query_result(struct pipe_context
*_pipe
,
342 struct pipe_query
*query
,
346 struct trace_context
*tr_ctx
= trace_context(_pipe
);
347 struct pipe_context
*pipe
= tr_ctx
->pipe
;
351 trace_dump_call_begin("pipe_context", "get_query_result");
353 trace_dump_arg(ptr
, pipe
);
355 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);;
358 trace_dump_arg(uint
, result
);
359 trace_dump_ret(bool, _result
);
361 trace_dump_call_end();
368 trace_context_create_blend_state(struct pipe_context
*_pipe
,
369 const struct pipe_blend_state
*state
)
371 struct trace_context
*tr_ctx
= trace_context(_pipe
);
372 struct pipe_context
*pipe
= tr_ctx
->pipe
;
375 trace_dump_call_begin("pipe_context", "create_blend_state");
377 trace_dump_arg(ptr
, pipe
);
378 trace_dump_arg(blend_state
, state
);
380 result
= pipe
->create_blend_state(pipe
, state
);;
382 trace_dump_ret(ptr
, result
);
384 trace_dump_call_end();
391 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
394 struct trace_context
*tr_ctx
= trace_context(_pipe
);
395 struct pipe_context
*pipe
= tr_ctx
->pipe
;
397 trace_dump_call_begin("pipe_context", "bind_blend_state");
399 trace_dump_arg(ptr
, pipe
);
400 trace_dump_arg(ptr
, state
);
402 pipe
->bind_blend_state(pipe
, state
);;
404 trace_dump_call_end();
409 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
412 struct trace_context
*tr_ctx
= trace_context(_pipe
);
413 struct pipe_context
*pipe
= tr_ctx
->pipe
;
415 trace_dump_call_begin("pipe_context", "delete_blend_state");
417 trace_dump_arg(ptr
, pipe
);
418 trace_dump_arg(ptr
, state
);
420 pipe
->delete_blend_state(pipe
, state
);;
422 trace_dump_call_end();
427 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
428 const struct pipe_sampler_state
*state
)
430 struct trace_context
*tr_ctx
= trace_context(_pipe
);
431 struct pipe_context
*pipe
= tr_ctx
->pipe
;
434 trace_dump_call_begin("pipe_context", "create_sampler_state");
436 trace_dump_arg(ptr
, pipe
);
437 trace_dump_arg(sampler_state
, state
);
439 result
= pipe
->create_sampler_state(pipe
, state
);;
441 trace_dump_ret(ptr
, result
);
443 trace_dump_call_end();
450 trace_context_bind_sampler_states(struct pipe_context
*_pipe
,
451 unsigned num_states
, void **states
)
453 struct trace_context
*tr_ctx
= trace_context(_pipe
);
454 struct pipe_context
*pipe
= tr_ctx
->pipe
;
456 trace_dump_call_begin("pipe_context", "bind_sampler_states");
458 trace_dump_arg(ptr
, pipe
);
459 trace_dump_arg(uint
, num_states
);
460 trace_dump_arg_array(ptr
, states
, num_states
);
462 pipe
->bind_sampler_states(pipe
, num_states
, states
);;
464 trace_dump_call_end();
469 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
472 struct trace_context
*tr_ctx
= trace_context(_pipe
);
473 struct pipe_context
*pipe
= tr_ctx
->pipe
;
475 trace_dump_call_begin("pipe_context", "delete_sampler_state");
477 trace_dump_arg(ptr
, pipe
);
478 trace_dump_arg(ptr
, state
);
480 pipe
->delete_sampler_state(pipe
, state
);;
482 trace_dump_call_end();
487 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
488 const struct pipe_rasterizer_state
*state
)
490 struct trace_context
*tr_ctx
= trace_context(_pipe
);
491 struct pipe_context
*pipe
= tr_ctx
->pipe
;
494 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
496 trace_dump_arg(ptr
, pipe
);
497 trace_dump_arg(rasterizer_state
, state
);
499 result
= pipe
->create_rasterizer_state(pipe
, state
);;
501 trace_dump_ret(ptr
, result
);
503 trace_dump_call_end();
510 trace_context_bind_rasterizer_state(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_rasterizer_state");
518 trace_dump_arg(ptr
, pipe
);
519 trace_dump_arg(ptr
, state
);
521 pipe
->bind_rasterizer_state(pipe
, state
);;
523 trace_dump_call_end();
528 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
531 struct trace_context
*tr_ctx
= trace_context(_pipe
);
532 struct pipe_context
*pipe
= tr_ctx
->pipe
;
534 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
536 trace_dump_arg(ptr
, pipe
);
537 trace_dump_arg(ptr
, state
);
539 pipe
->delete_rasterizer_state(pipe
, state
);;
541 trace_dump_call_end();
546 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
547 const struct pipe_depth_stencil_alpha_state
*state
)
549 struct trace_context
*tr_ctx
= trace_context(_pipe
);
550 struct pipe_context
*pipe
= tr_ctx
->pipe
;
553 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
555 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);;
557 trace_dump_arg(ptr
, pipe
);
558 trace_dump_arg(depth_stencil_alpha_state
, state
);
560 trace_dump_ret(ptr
, result
);
562 trace_dump_call_end();
569 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
572 struct trace_context
*tr_ctx
= trace_context(_pipe
);
573 struct pipe_context
*pipe
= tr_ctx
->pipe
;
575 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
577 trace_dump_arg(ptr
, pipe
);
578 trace_dump_arg(ptr
, state
);
580 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);;
582 trace_dump_call_end();
587 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
590 struct trace_context
*tr_ctx
= trace_context(_pipe
);
591 struct pipe_context
*pipe
= tr_ctx
->pipe
;
593 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
595 trace_dump_arg(ptr
, pipe
);
596 trace_dump_arg(ptr
, state
);
598 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);;
600 trace_dump_call_end();
605 trace_context_create_fs_state(struct pipe_context
*_pipe
,
606 const struct pipe_shader_state
*state
)
608 struct trace_context
*tr_ctx
= trace_context(_pipe
);
609 struct pipe_context
*pipe
= tr_ctx
->pipe
;
612 trace_dump_call_begin("pipe_context", "create_fs_state");
614 trace_dump_arg(ptr
, pipe
);
615 trace_dump_arg(shader_state
, state
);
617 result
= pipe
->create_fs_state(pipe
, state
);;
619 trace_dump_ret(ptr
, result
);
621 trace_dump_call_end();
623 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
630 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
633 struct trace_context
*tr_ctx
= trace_context(_pipe
);
634 struct trace_shader
*tr_shdr
= trace_shader(_state
);
635 struct pipe_context
*pipe
= tr_ctx
->pipe
;
636 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
638 trace_dump_call_begin("pipe_context", "bind_fs_state");
640 trace_dump_arg(ptr
, pipe
);
641 trace_dump_arg(ptr
, state
);
643 tr_ctx
->curr
.fs
= tr_shdr
;
645 if (tr_shdr
&& tr_shdr
->replaced
)
646 state
= tr_shdr
->replaced
;
648 pipe
->bind_fs_state(pipe
, state
);
650 trace_dump_call_end();
655 trace_context_delete_fs_state(struct pipe_context
*_pipe
,
658 struct trace_context
*tr_ctx
= trace_context(_pipe
);
659 struct trace_shader
*tr_shdr
= trace_shader(_state
);
660 struct pipe_context
*pipe
= tr_ctx
->pipe
;
661 void *state
= tr_shdr
->state
;
663 trace_dump_call_begin("pipe_context", "delete_fs_state");
665 trace_dump_arg(ptr
, pipe
);
666 trace_dump_arg(ptr
, state
);
668 pipe
->delete_fs_state(pipe
, state
);
670 trace_dump_call_end();
672 trace_shader_destroy(tr_ctx
, tr_shdr
);
677 trace_context_create_vs_state(struct pipe_context
*_pipe
,
678 const struct pipe_shader_state
*state
)
680 struct trace_context
*tr_ctx
= trace_context(_pipe
);
681 struct pipe_context
*pipe
= tr_ctx
->pipe
;
684 trace_dump_call_begin("pipe_context", "create_vs_state");
686 trace_dump_arg(ptr
, pipe
);
687 trace_dump_arg(shader_state
, state
);
689 result
= pipe
->create_vs_state(pipe
, state
);
691 trace_dump_ret(ptr
, result
);
693 trace_dump_call_end();
695 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
702 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
705 struct trace_context
*tr_ctx
= trace_context(_pipe
);
706 struct trace_shader
*tr_shdr
= trace_shader(_state
);
707 struct pipe_context
*pipe
= tr_ctx
->pipe
;
708 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
710 trace_dump_call_begin("pipe_context", "bind_vs_state");
712 trace_dump_arg(ptr
, pipe
);
713 trace_dump_arg(ptr
, state
);
715 tr_ctx
->curr
.vs
= tr_shdr
;
717 if (tr_shdr
&& tr_shdr
->replaced
)
718 state
= tr_shdr
->replaced
;
720 pipe
->bind_vs_state(pipe
, state
);;
722 trace_dump_call_end();
727 trace_context_delete_vs_state(struct pipe_context
*_pipe
,
730 struct trace_context
*tr_ctx
= trace_context(_pipe
);
731 struct trace_shader
*tr_shdr
= trace_shader(_state
);
732 struct pipe_context
*pipe
= tr_ctx
->pipe
;
733 void *state
= tr_shdr
->state
;
735 trace_dump_call_begin("pipe_context", "delete_vs_state");
737 trace_dump_arg(ptr
, pipe
);
738 trace_dump_arg(ptr
, state
);
740 pipe
->delete_vs_state(pipe
, state
);;
742 trace_dump_call_end();
744 trace_shader_destroy(tr_ctx
, tr_shdr
);
749 trace_context_set_blend_color(struct pipe_context
*_pipe
,
750 const struct pipe_blend_color
*state
)
752 struct trace_context
*tr_ctx
= trace_context(_pipe
);
753 struct pipe_context
*pipe
= tr_ctx
->pipe
;
755 trace_dump_call_begin("pipe_context", "set_blend_color");
757 trace_dump_arg(ptr
, pipe
);
758 trace_dump_arg(blend_color
, state
);
760 pipe
->set_blend_color(pipe
, state
);;
762 trace_dump_call_end();
767 trace_context_set_clip_state(struct pipe_context
*_pipe
,
768 const struct pipe_clip_state
*state
)
770 struct trace_context
*tr_ctx
= trace_context(_pipe
);
771 struct pipe_context
*pipe
= tr_ctx
->pipe
;
773 trace_dump_call_begin("pipe_context", "set_clip_state");
775 trace_dump_arg(ptr
, pipe
);
776 trace_dump_arg(clip_state
, state
);
778 pipe
->set_clip_state(pipe
, state
);;
780 trace_dump_call_end();
785 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
786 uint shader
, uint index
,
787 const struct pipe_constant_buffer
*buffer
)
789 struct trace_context
*tr_ctx
= trace_context(_pipe
);
790 struct pipe_context
*pipe
= tr_ctx
->pipe
;
793 trace_screen_user_buffer_update(_pipe
->screen
, buffer
->buffer
);
795 trace_dump_call_begin("pipe_context", "set_constant_buffer");
797 trace_dump_arg(ptr
, pipe
);
798 trace_dump_arg(uint
, shader
);
799 trace_dump_arg(uint
, index
);
800 trace_dump_arg(constant_buffer
, buffer
);
803 struct pipe_constant_buffer _buffer
;
804 _buffer
.buffer
= trace_buffer_unwrap(tr_ctx
, buffer
->buffer
);
805 pipe
->set_constant_buffer(pipe
, shader
, index
, &_buffer
);
807 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
810 trace_dump_call_end();
815 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
816 const struct pipe_framebuffer_state
*state
)
818 struct trace_context
*tr_ctx
= trace_context(_pipe
);
819 struct pipe_context
*pipe
= tr_ctx
->pipe
;
820 struct pipe_framebuffer_state unwrapped_state
;
824 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
825 for (i
= 0; i
< state
->nr_cbufs
; i
++)
827 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
829 tr_ctx
->curr
.cbufs
[i
] = NULL
;
831 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
833 tr_ctx
->curr
.zsbuf
= NULL
;
836 /* Unwrap the input state */
837 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
838 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
839 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
840 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
841 unwrapped_state
.cbufs
[i
] = NULL
;
842 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
843 state
= &unwrapped_state
;
845 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
847 trace_dump_arg(ptr
, pipe
);
848 trace_dump_arg(framebuffer_state
, state
);
850 pipe
->set_framebuffer_state(pipe
, state
);;
852 trace_dump_call_end();
857 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
858 const struct pipe_poly_stipple
*state
)
860 struct trace_context
*tr_ctx
= trace_context(_pipe
);
861 struct pipe_context
*pipe
= tr_ctx
->pipe
;
863 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
865 trace_dump_arg(ptr
, pipe
);
866 trace_dump_arg(poly_stipple
, state
);
868 pipe
->set_polygon_stipple(pipe
, state
);;
870 trace_dump_call_end();
875 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
876 const struct pipe_scissor_state
*state
)
878 struct trace_context
*tr_ctx
= trace_context(_pipe
);
879 struct pipe_context
*pipe
= tr_ctx
->pipe
;
881 trace_dump_call_begin("pipe_context", "set_scissor_state");
883 trace_dump_arg(ptr
, pipe
);
884 trace_dump_arg(scissor_state
, state
);
886 pipe
->set_scissor_state(pipe
, state
);;
888 trace_dump_call_end();
893 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
894 const struct pipe_viewport_state
*state
)
896 struct trace_context
*tr_ctx
= trace_context(_pipe
);
897 struct pipe_context
*pipe
= tr_ctx
->pipe
;
899 trace_dump_call_begin("pipe_context", "set_viewport_state");
901 trace_dump_arg(ptr
, pipe
);
902 trace_dump_arg(viewport_state
, state
);
904 pipe
->set_viewport_state(pipe
, state
);;
906 trace_dump_call_end();
911 trace_context_set_sampler_textures(struct pipe_context
*_pipe
,
912 unsigned num_textures
,
913 struct pipe_texture
**textures
)
915 struct trace_context
*tr_ctx
= trace_context(_pipe
);
916 struct pipe_context
*pipe
= tr_ctx
->pipe
;
917 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
920 for(i
= 0; i
< num_textures
; ++i
)
921 unwrapped_textures
[i
] = trace_texture_unwrap(tr_ctx
, textures
[i
]);
922 textures
= unwrapped_textures
;
924 trace_dump_call_begin("pipe_context", "set_sampler_textures");
926 trace_dump_arg(ptr
, pipe
);
927 trace_dump_arg(uint
, num_textures
);
928 trace_dump_arg_array(ptr
, textures
, num_textures
);
930 pipe
->set_sampler_textures(pipe
, num_textures
, textures
);;
932 trace_dump_call_end();
937 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
938 unsigned num_buffers
,
939 const struct pipe_vertex_buffer
*buffers
)
941 struct trace_context
*tr_ctx
= trace_context(_pipe
);
942 struct pipe_context
*pipe
= tr_ctx
->pipe
;
945 for(i
= 0; i
< num_buffers
; ++i
)
946 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
948 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
950 trace_dump_arg(ptr
, pipe
);
951 trace_dump_arg(uint
, num_buffers
);
953 trace_dump_arg_begin("buffers");
954 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
955 trace_dump_arg_end();
958 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
959 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
960 for (i
= 0; i
< num_buffers
; i
++)
961 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
962 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
965 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
968 trace_dump_call_end();
973 trace_context_set_vertex_elements(struct pipe_context
*_pipe
,
974 unsigned num_elements
,
975 const struct pipe_vertex_element
*elements
)
977 struct trace_context
*tr_ctx
= trace_context(_pipe
);
978 struct pipe_context
*pipe
= tr_ctx
->pipe
;
980 trace_dump_call_begin("pipe_context", "set_vertex_elements");
982 trace_dump_arg(ptr
, pipe
);
983 trace_dump_arg(uint
, num_elements
);
985 trace_dump_arg_begin("elements");
986 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
987 trace_dump_arg_end();
989 pipe
->set_vertex_elements(pipe
, num_elements
, elements
);;
991 trace_dump_call_end();
996 trace_context_surface_copy(struct pipe_context
*_pipe
,
997 struct pipe_surface
*dest
,
998 unsigned destx
, unsigned desty
,
999 struct pipe_surface
*src
,
1000 unsigned srcx
, unsigned srcy
,
1001 unsigned width
, unsigned height
)
1003 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1004 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1006 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1007 src
= trace_surface_unwrap(tr_ctx
, src
);
1009 trace_dump_call_begin("pipe_context", "surface_copy");
1011 trace_dump_arg(ptr
, pipe
);
1012 trace_dump_arg(ptr
, dest
);
1013 trace_dump_arg(uint
, destx
);
1014 trace_dump_arg(uint
, desty
);
1015 trace_dump_arg(ptr
, src
);
1016 trace_dump_arg(uint
, srcx
);
1017 trace_dump_arg(uint
, srcy
);
1018 trace_dump_arg(uint
, width
);
1019 trace_dump_arg(uint
, height
);
1021 pipe
->surface_copy(pipe
,
1023 src
, srcx
, srcy
, width
, height
);
1025 trace_dump_call_end();
1030 trace_context_surface_fill(struct pipe_context
*_pipe
,
1031 struct pipe_surface
*dst
,
1032 unsigned dstx
, unsigned dsty
,
1033 unsigned width
, unsigned height
,
1036 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1037 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1039 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1041 trace_dump_call_begin("pipe_context", "surface_fill");
1043 trace_dump_arg(ptr
, pipe
);
1044 trace_dump_arg(ptr
, dst
);
1045 trace_dump_arg(uint
, dstx
);
1046 trace_dump_arg(uint
, dsty
);
1047 trace_dump_arg(uint
, width
);
1048 trace_dump_arg(uint
, height
);
1050 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);;
1052 trace_dump_call_end();
1057 trace_context_clear(struct pipe_context
*_pipe
,
1063 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1064 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1066 trace_dump_call_begin("pipe_context", "clear");
1068 trace_dump_arg(ptr
, pipe
);
1069 trace_dump_arg(uint
, buffers
);
1070 trace_dump_arg_array(float, rgba
, 4);
1071 trace_dump_arg(float, depth
);
1072 trace_dump_arg(uint
, stencil
);
1074 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1076 trace_dump_call_end();
1081 trace_context_flush(struct pipe_context
*_pipe
,
1083 struct pipe_fence_handle
**fence
)
1085 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1086 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1088 trace_dump_call_begin("pipe_context", "flush");
1090 trace_dump_arg(ptr
, pipe
);
1091 trace_dump_arg(uint
, flags
);
1093 pipe
->flush(pipe
, flags
, fence
);;
1096 trace_dump_ret(ptr
, *fence
);
1098 trace_dump_call_end();
1103 trace_context_destroy(struct pipe_context
*_pipe
)
1105 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1106 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1107 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1109 trace_dump_call_begin("pipe_context", "destroy");
1110 trace_dump_arg(ptr
, pipe
);
1111 trace_dump_call_end();
1113 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1115 pipe
->destroy(pipe
);
1121 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1122 struct pipe_texture
*_texture
,
1123 unsigned face
, unsigned level
)
1125 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1126 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1127 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1128 struct pipe_texture
*texture
= tr_tex
->texture
;
1129 unsigned int referenced
;
1131 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1132 trace_dump_arg(ptr
, pipe
);
1133 trace_dump_arg(ptr
, texture
);
1134 trace_dump_arg(uint
, face
);
1135 trace_dump_arg(uint
, level
);
1137 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1139 trace_dump_ret(uint
, referenced
);
1140 trace_dump_call_end();
1146 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1147 struct pipe_buffer
*_buf
)
1149 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1150 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1151 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1152 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1153 unsigned int referenced
;
1155 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1156 trace_dump_arg(ptr
, pipe
);
1157 trace_dump_arg(ptr
, buf
);
1159 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1161 trace_dump_ret(uint
, referenced
);
1162 trace_dump_call_end();
1167 static const struct debug_named_value rbug_blocker_flags
[] = {
1173 struct pipe_context
*
1174 trace_context_create(struct pipe_screen
*_screen
,
1175 struct pipe_context
*pipe
)
1177 struct trace_screen
*tr_scr
;
1178 struct trace_context
*tr_ctx
;
1179 struct pipe_screen
*screen
;
1184 if(!trace_enabled())
1187 tr_scr
= trace_screen(_screen
);
1188 screen
= tr_scr
->screen
;
1190 tr_ctx
= CALLOC_STRUCT(trace_context
);
1194 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1197 pipe_mutex_init(tr_ctx
->draw_mutex
);
1198 pipe_condvar_init(tr_ctx
->draw_cond
);
1199 pipe_mutex_init(tr_ctx
->list_mutex
);
1200 make_empty_list(&tr_ctx
->shaders
);
1202 tr_ctx
->base
.winsys
= _screen
->winsys
;
1203 tr_ctx
->base
.screen
= _screen
;
1204 tr_ctx
->base
.destroy
= trace_context_destroy
;
1205 tr_ctx
->base
.set_edgeflags
= trace_context_set_edgeflags
;
1206 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1207 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1208 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1209 tr_ctx
->base
.create_query
= trace_context_create_query
;
1210 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1211 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1212 tr_ctx
->base
.end_query
= trace_context_end_query
;
1213 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1214 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1215 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1216 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1217 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1218 tr_ctx
->base
.bind_sampler_states
= trace_context_bind_sampler_states
;
1219 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1220 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1221 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1222 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1223 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1224 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1225 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1226 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1227 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1228 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1229 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1230 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1231 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1232 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1233 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1234 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1235 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1236 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1237 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1238 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1239 tr_ctx
->base
.set_sampler_textures
= trace_context_set_sampler_textures
;
1240 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1241 tr_ctx
->base
.set_vertex_elements
= trace_context_set_vertex_elements
;
1242 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1243 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1244 tr_ctx
->base
.clear
= trace_context_clear
;
1245 tr_ctx
->base
.flush
= trace_context_flush
;
1246 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1247 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1249 tr_ctx
->pipe
= pipe
;
1251 trace_dump_call_begin("", "pipe_context_create");
1252 trace_dump_arg(ptr
, screen
);
1253 trace_dump_ret(ptr
, pipe
);
1254 trace_dump_call_end();
1256 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1258 return &tr_ctx
->base
;