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 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
137 pipe_mutex_lock(tr_ctx
->draw_mutex
);
141 pipe_mutex_unlock(tr_ctx
->draw_mutex
);
144 static INLINE boolean
145 trace_context_draw_arrays(struct pipe_context
*_pipe
,
146 unsigned mode
, unsigned start
, unsigned count
)
148 struct trace_context
*tr_ctx
= trace_context(_pipe
);
149 struct pipe_context
*pipe
= tr_ctx
->pipe
;
152 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
155 trace_context_draw_block(tr_ctx
, 1);
157 trace_dump_call_begin("pipe_context", "draw_arrays");
159 trace_dump_arg(ptr
, pipe
);
160 trace_dump_arg(uint
, mode
);
161 trace_dump_arg(uint
, start
);
162 trace_dump_arg(uint
, count
);
164 result
= pipe
->draw_arrays(pipe
, mode
, start
, count
);;
166 trace_dump_ret(bool, result
);
168 trace_dump_call_end();
170 trace_context_draw_block(tr_ctx
, 2);
176 static INLINE boolean
177 trace_context_draw_elements(struct pipe_context
*_pipe
,
178 struct pipe_buffer
*_indexBuffer
,
180 unsigned mode
, unsigned start
, unsigned count
)
182 struct trace_context
*tr_ctx
= trace_context(_pipe
);
183 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
184 struct pipe_context
*pipe
= tr_ctx
->pipe
;
185 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
188 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
191 trace_context_draw_block(tr_ctx
, 1);
193 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
195 trace_dump_call_begin("pipe_context", "draw_elements");
197 trace_dump_arg(ptr
, pipe
);
198 trace_dump_arg(ptr
, indexBuffer
);
199 trace_dump_arg(uint
, indexSize
);
200 trace_dump_arg(uint
, mode
);
201 trace_dump_arg(uint
, start
);
202 trace_dump_arg(uint
, count
);
204 result
= pipe
->draw_elements(pipe
, indexBuffer
, indexSize
, mode
, start
, count
);;
206 trace_dump_ret(bool, result
);
208 trace_dump_call_end();
210 trace_context_draw_block(tr_ctx
, 2);
216 static INLINE boolean
217 trace_context_draw_range_elements(struct pipe_context
*_pipe
,
218 struct pipe_buffer
*_indexBuffer
,
226 struct trace_context
*tr_ctx
= trace_context(_pipe
);
227 struct trace_buffer
*tr_buf
= trace_buffer(_indexBuffer
);
228 struct pipe_context
*pipe
= tr_ctx
->pipe
;
229 struct pipe_buffer
*indexBuffer
= tr_buf
->buffer
;
232 if (tr_ctx
->curr
.fs
->disabled
|| tr_ctx
->curr
.vs
->disabled
)
235 trace_context_draw_block(tr_ctx
, 1);
237 trace_screen_user_buffer_update(_pipe
->screen
, indexBuffer
);
239 trace_dump_call_begin("pipe_context", "draw_range_elements");
241 trace_dump_arg(ptr
, pipe
);
242 trace_dump_arg(ptr
, indexBuffer
);
243 trace_dump_arg(uint
, indexSize
);
244 trace_dump_arg(uint
, minIndex
);
245 trace_dump_arg(uint
, maxIndex
);
246 trace_dump_arg(uint
, mode
);
247 trace_dump_arg(uint
, start
);
248 trace_dump_arg(uint
, count
);
250 result
= pipe
->draw_range_elements(pipe
,
252 indexSize
, minIndex
, maxIndex
,
255 trace_dump_ret(bool, result
);
257 trace_dump_call_end();
259 trace_context_draw_block(tr_ctx
, 2);
265 static INLINE
struct pipe_query
*
266 trace_context_create_query(struct pipe_context
*_pipe
,
269 struct trace_context
*tr_ctx
= trace_context(_pipe
);
270 struct pipe_context
*pipe
= tr_ctx
->pipe
;
271 struct pipe_query
*result
;
273 trace_dump_call_begin("pipe_context", "create_query");
275 trace_dump_arg(ptr
, pipe
);
276 trace_dump_arg(uint
, query_type
);
278 result
= pipe
->create_query(pipe
, query_type
);;
280 trace_dump_ret(ptr
, result
);
282 trace_dump_call_end();
289 trace_context_destroy_query(struct pipe_context
*_pipe
,
290 struct pipe_query
*query
)
292 struct trace_context
*tr_ctx
= trace_context(_pipe
);
293 struct pipe_context
*pipe
= tr_ctx
->pipe
;
295 trace_dump_call_begin("pipe_context", "destroy_query");
297 trace_dump_arg(ptr
, pipe
);
298 trace_dump_arg(ptr
, query
);
300 pipe
->destroy_query(pipe
, query
);;
302 trace_dump_call_end();
307 trace_context_begin_query(struct pipe_context
*_pipe
,
308 struct pipe_query
*query
)
310 struct trace_context
*tr_ctx
= trace_context(_pipe
);
311 struct pipe_context
*pipe
= tr_ctx
->pipe
;
313 trace_dump_call_begin("pipe_context", "begin_query");
315 trace_dump_arg(ptr
, pipe
);
316 trace_dump_arg(ptr
, query
);
318 pipe
->begin_query(pipe
, query
);;
320 trace_dump_call_end();
325 trace_context_end_query(struct pipe_context
*_pipe
,
326 struct pipe_query
*query
)
328 struct trace_context
*tr_ctx
= trace_context(_pipe
);
329 struct pipe_context
*pipe
= tr_ctx
->pipe
;
331 trace_dump_call_begin("pipe_context", "end_query");
333 trace_dump_arg(ptr
, pipe
);
334 trace_dump_arg(ptr
, query
);
336 pipe
->end_query(pipe
, query
);
338 trace_dump_call_end();
342 static INLINE boolean
343 trace_context_get_query_result(struct pipe_context
*_pipe
,
344 struct pipe_query
*query
,
348 struct trace_context
*tr_ctx
= trace_context(_pipe
);
349 struct pipe_context
*pipe
= tr_ctx
->pipe
;
353 trace_dump_call_begin("pipe_context", "get_query_result");
355 trace_dump_arg(ptr
, pipe
);
357 _result
= pipe
->get_query_result(pipe
, query
, wait
, presult
);;
360 trace_dump_arg(uint
, result
);
361 trace_dump_ret(bool, _result
);
363 trace_dump_call_end();
370 trace_context_create_blend_state(struct pipe_context
*_pipe
,
371 const struct pipe_blend_state
*state
)
373 struct trace_context
*tr_ctx
= trace_context(_pipe
);
374 struct pipe_context
*pipe
= tr_ctx
->pipe
;
377 trace_dump_call_begin("pipe_context", "create_blend_state");
379 trace_dump_arg(ptr
, pipe
);
380 trace_dump_arg(blend_state
, state
);
382 result
= pipe
->create_blend_state(pipe
, state
);;
384 trace_dump_ret(ptr
, result
);
386 trace_dump_call_end();
393 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
396 struct trace_context
*tr_ctx
= trace_context(_pipe
);
397 struct pipe_context
*pipe
= tr_ctx
->pipe
;
399 trace_dump_call_begin("pipe_context", "bind_blend_state");
401 trace_dump_arg(ptr
, pipe
);
402 trace_dump_arg(ptr
, state
);
404 pipe
->bind_blend_state(pipe
, state
);;
406 trace_dump_call_end();
411 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
414 struct trace_context
*tr_ctx
= trace_context(_pipe
);
415 struct pipe_context
*pipe
= tr_ctx
->pipe
;
417 trace_dump_call_begin("pipe_context", "delete_blend_state");
419 trace_dump_arg(ptr
, pipe
);
420 trace_dump_arg(ptr
, state
);
422 pipe
->delete_blend_state(pipe
, state
);;
424 trace_dump_call_end();
429 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
430 const struct pipe_sampler_state
*state
)
432 struct trace_context
*tr_ctx
= trace_context(_pipe
);
433 struct pipe_context
*pipe
= tr_ctx
->pipe
;
436 trace_dump_call_begin("pipe_context", "create_sampler_state");
438 trace_dump_arg(ptr
, pipe
);
439 trace_dump_arg(sampler_state
, state
);
441 result
= pipe
->create_sampler_state(pipe
, state
);;
443 trace_dump_ret(ptr
, result
);
445 trace_dump_call_end();
452 trace_context_bind_sampler_states(struct pipe_context
*_pipe
,
453 unsigned num_states
, void **states
)
455 struct trace_context
*tr_ctx
= trace_context(_pipe
);
456 struct pipe_context
*pipe
= tr_ctx
->pipe
;
458 trace_dump_call_begin("pipe_context", "bind_sampler_states");
460 trace_dump_arg(ptr
, pipe
);
461 trace_dump_arg(uint
, num_states
);
462 trace_dump_arg_array(ptr
, states
, num_states
);
464 pipe
->bind_sampler_states(pipe
, num_states
, states
);;
466 trace_dump_call_end();
471 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
474 struct trace_context
*tr_ctx
= trace_context(_pipe
);
475 struct pipe_context
*pipe
= tr_ctx
->pipe
;
477 trace_dump_call_begin("pipe_context", "delete_sampler_state");
479 trace_dump_arg(ptr
, pipe
);
480 trace_dump_arg(ptr
, state
);
482 pipe
->delete_sampler_state(pipe
, state
);;
484 trace_dump_call_end();
489 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
490 const struct pipe_rasterizer_state
*state
)
492 struct trace_context
*tr_ctx
= trace_context(_pipe
);
493 struct pipe_context
*pipe
= tr_ctx
->pipe
;
496 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
498 trace_dump_arg(ptr
, pipe
);
499 trace_dump_arg(rasterizer_state
, state
);
501 result
= pipe
->create_rasterizer_state(pipe
, state
);;
503 trace_dump_ret(ptr
, result
);
505 trace_dump_call_end();
512 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
515 struct trace_context
*tr_ctx
= trace_context(_pipe
);
516 struct pipe_context
*pipe
= tr_ctx
->pipe
;
518 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
520 trace_dump_arg(ptr
, pipe
);
521 trace_dump_arg(ptr
, state
);
523 pipe
->bind_rasterizer_state(pipe
, state
);;
525 trace_dump_call_end();
530 trace_context_delete_rasterizer_state(struct pipe_context
*_pipe
,
533 struct trace_context
*tr_ctx
= trace_context(_pipe
);
534 struct pipe_context
*pipe
= tr_ctx
->pipe
;
536 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
538 trace_dump_arg(ptr
, pipe
);
539 trace_dump_arg(ptr
, state
);
541 pipe
->delete_rasterizer_state(pipe
, state
);;
543 trace_dump_call_end();
548 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
549 const struct pipe_depth_stencil_alpha_state
*state
)
551 struct trace_context
*tr_ctx
= trace_context(_pipe
);
552 struct pipe_context
*pipe
= tr_ctx
->pipe
;
555 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
557 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);;
559 trace_dump_arg(ptr
, pipe
);
560 trace_dump_arg(depth_stencil_alpha_state
, state
);
562 trace_dump_ret(ptr
, result
);
564 trace_dump_call_end();
571 trace_context_bind_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
574 struct trace_context
*tr_ctx
= trace_context(_pipe
);
575 struct pipe_context
*pipe
= tr_ctx
->pipe
;
577 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
579 trace_dump_arg(ptr
, pipe
);
580 trace_dump_arg(ptr
, state
);
582 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);;
584 trace_dump_call_end();
589 trace_context_delete_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
592 struct trace_context
*tr_ctx
= trace_context(_pipe
);
593 struct pipe_context
*pipe
= tr_ctx
->pipe
;
595 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
597 trace_dump_arg(ptr
, pipe
);
598 trace_dump_arg(ptr
, state
);
600 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);;
602 trace_dump_call_end();
607 trace_context_create_fs_state(struct pipe_context
*_pipe
,
608 const struct pipe_shader_state
*state
)
610 struct trace_context
*tr_ctx
= trace_context(_pipe
);
611 struct pipe_context
*pipe
= tr_ctx
->pipe
;
614 trace_dump_call_begin("pipe_context", "create_fs_state");
616 trace_dump_arg(ptr
, pipe
);
617 trace_dump_arg(shader_state
, state
);
619 result
= pipe
->create_fs_state(pipe
, state
);;
621 trace_dump_ret(ptr
, result
);
623 trace_dump_call_end();
625 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_FRAGMENT
);
632 trace_context_bind_fs_state(struct pipe_context
*_pipe
,
635 struct trace_context
*tr_ctx
= trace_context(_pipe
);
636 struct trace_shader
*tr_shdr
= trace_shader(_state
);
637 struct pipe_context
*pipe
= tr_ctx
->pipe
;
638 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
640 trace_dump_call_begin("pipe_context", "bind_fs_state");
642 trace_dump_arg(ptr
, pipe
);
643 trace_dump_arg(ptr
, state
);
645 tr_ctx
->curr
.fs
= tr_shdr
;
647 if (tr_shdr
&& tr_shdr
->replaced
)
648 state
= tr_shdr
->replaced
;
650 pipe
->bind_fs_state(pipe
, state
);
652 trace_dump_call_end();
657 trace_context_delete_fs_state(struct pipe_context
*_pipe
,
660 struct trace_context
*tr_ctx
= trace_context(_pipe
);
661 struct trace_shader
*tr_shdr
= trace_shader(_state
);
662 struct pipe_context
*pipe
= tr_ctx
->pipe
;
663 void *state
= tr_shdr
->state
;
665 trace_dump_call_begin("pipe_context", "delete_fs_state");
667 trace_dump_arg(ptr
, pipe
);
668 trace_dump_arg(ptr
, state
);
670 pipe
->delete_fs_state(pipe
, state
);
672 trace_dump_call_end();
674 trace_shader_destroy(tr_ctx
, tr_shdr
);
679 trace_context_create_vs_state(struct pipe_context
*_pipe
,
680 const struct pipe_shader_state
*state
)
682 struct trace_context
*tr_ctx
= trace_context(_pipe
);
683 struct pipe_context
*pipe
= tr_ctx
->pipe
;
686 trace_dump_call_begin("pipe_context", "create_vs_state");
688 trace_dump_arg(ptr
, pipe
);
689 trace_dump_arg(shader_state
, state
);
691 result
= pipe
->create_vs_state(pipe
, state
);
693 trace_dump_ret(ptr
, result
);
695 trace_dump_call_end();
697 result
= trace_shader_create(tr_ctx
, state
, result
, TRACE_SHADER_VERTEX
);
704 trace_context_bind_vs_state(struct pipe_context
*_pipe
,
707 struct trace_context
*tr_ctx
= trace_context(_pipe
);
708 struct trace_shader
*tr_shdr
= trace_shader(_state
);
709 struct pipe_context
*pipe
= tr_ctx
->pipe
;
710 void *state
= tr_shdr
? tr_shdr
->state
: NULL
;
712 trace_dump_call_begin("pipe_context", "bind_vs_state");
714 trace_dump_arg(ptr
, pipe
);
715 trace_dump_arg(ptr
, state
);
717 tr_ctx
->curr
.vs
= tr_shdr
;
719 if (tr_shdr
&& tr_shdr
->replaced
)
720 state
= tr_shdr
->replaced
;
722 pipe
->bind_vs_state(pipe
, state
);;
724 trace_dump_call_end();
729 trace_context_delete_vs_state(struct pipe_context
*_pipe
,
732 struct trace_context
*tr_ctx
= trace_context(_pipe
);
733 struct trace_shader
*tr_shdr
= trace_shader(_state
);
734 struct pipe_context
*pipe
= tr_ctx
->pipe
;
735 void *state
= tr_shdr
->state
;
737 trace_dump_call_begin("pipe_context", "delete_vs_state");
739 trace_dump_arg(ptr
, pipe
);
740 trace_dump_arg(ptr
, state
);
742 pipe
->delete_vs_state(pipe
, state
);;
744 trace_dump_call_end();
746 trace_shader_destroy(tr_ctx
, tr_shdr
);
751 trace_context_set_blend_color(struct pipe_context
*_pipe
,
752 const struct pipe_blend_color
*state
)
754 struct trace_context
*tr_ctx
= trace_context(_pipe
);
755 struct pipe_context
*pipe
= tr_ctx
->pipe
;
757 trace_dump_call_begin("pipe_context", "set_blend_color");
759 trace_dump_arg(ptr
, pipe
);
760 trace_dump_arg(blend_color
, state
);
762 pipe
->set_blend_color(pipe
, state
);;
764 trace_dump_call_end();
769 trace_context_set_clip_state(struct pipe_context
*_pipe
,
770 const struct pipe_clip_state
*state
)
772 struct trace_context
*tr_ctx
= trace_context(_pipe
);
773 struct pipe_context
*pipe
= tr_ctx
->pipe
;
775 trace_dump_call_begin("pipe_context", "set_clip_state");
777 trace_dump_arg(ptr
, pipe
);
778 trace_dump_arg(clip_state
, state
);
780 pipe
->set_clip_state(pipe
, state
);;
782 trace_dump_call_end();
787 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
788 uint shader
, uint index
,
789 const struct pipe_constant_buffer
*buffer
)
791 struct trace_context
*tr_ctx
= trace_context(_pipe
);
792 struct pipe_context
*pipe
= tr_ctx
->pipe
;
795 trace_screen_user_buffer_update(_pipe
->screen
, buffer
->buffer
);
797 trace_dump_call_begin("pipe_context", "set_constant_buffer");
799 trace_dump_arg(ptr
, pipe
);
800 trace_dump_arg(uint
, shader
);
801 trace_dump_arg(uint
, index
);
802 trace_dump_arg(constant_buffer
, buffer
);
805 struct pipe_constant_buffer _buffer
;
806 _buffer
.buffer
= trace_buffer_unwrap(tr_ctx
, buffer
->buffer
);
807 pipe
->set_constant_buffer(pipe
, shader
, index
, &_buffer
);
809 pipe
->set_constant_buffer(pipe
, shader
, index
, buffer
);
812 trace_dump_call_end();
817 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
818 const struct pipe_framebuffer_state
*state
)
820 struct trace_context
*tr_ctx
= trace_context(_pipe
);
821 struct pipe_context
*pipe
= tr_ctx
->pipe
;
822 struct pipe_framebuffer_state unwrapped_state
;
826 tr_ctx
->curr
.nr_cbufs
= state
->nr_cbufs
;
827 for (i
= 0; i
< state
->nr_cbufs
; i
++)
829 tr_ctx
->curr
.cbufs
[i
] = trace_texture(state
->cbufs
[i
]->texture
);
831 tr_ctx
->curr
.cbufs
[i
] = NULL
;
833 tr_ctx
->curr
.zsbuf
= trace_texture(state
->zsbuf
->texture
);
835 tr_ctx
->curr
.zsbuf
= NULL
;
838 /* Unwrap the input state */
839 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
840 for(i
= 0; i
< state
->nr_cbufs
; ++i
)
841 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
842 for(i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
843 unwrapped_state
.cbufs
[i
] = NULL
;
844 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
845 state
= &unwrapped_state
;
847 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
849 trace_dump_arg(ptr
, pipe
);
850 trace_dump_arg(framebuffer_state
, state
);
852 pipe
->set_framebuffer_state(pipe
, state
);;
854 trace_dump_call_end();
859 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
860 const struct pipe_poly_stipple
*state
)
862 struct trace_context
*tr_ctx
= trace_context(_pipe
);
863 struct pipe_context
*pipe
= tr_ctx
->pipe
;
865 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
867 trace_dump_arg(ptr
, pipe
);
868 trace_dump_arg(poly_stipple
, state
);
870 pipe
->set_polygon_stipple(pipe
, state
);;
872 trace_dump_call_end();
877 trace_context_set_scissor_state(struct pipe_context
*_pipe
,
878 const struct pipe_scissor_state
*state
)
880 struct trace_context
*tr_ctx
= trace_context(_pipe
);
881 struct pipe_context
*pipe
= tr_ctx
->pipe
;
883 trace_dump_call_begin("pipe_context", "set_scissor_state");
885 trace_dump_arg(ptr
, pipe
);
886 trace_dump_arg(scissor_state
, state
);
888 pipe
->set_scissor_state(pipe
, state
);;
890 trace_dump_call_end();
895 trace_context_set_viewport_state(struct pipe_context
*_pipe
,
896 const struct pipe_viewport_state
*state
)
898 struct trace_context
*tr_ctx
= trace_context(_pipe
);
899 struct pipe_context
*pipe
= tr_ctx
->pipe
;
901 trace_dump_call_begin("pipe_context", "set_viewport_state");
903 trace_dump_arg(ptr
, pipe
);
904 trace_dump_arg(viewport_state
, state
);
906 pipe
->set_viewport_state(pipe
, state
);;
908 trace_dump_call_end();
913 trace_context_set_sampler_textures(struct pipe_context
*_pipe
,
914 unsigned num_textures
,
915 struct pipe_texture
**textures
)
917 struct trace_context
*tr_ctx
= trace_context(_pipe
);
918 struct pipe_context
*pipe
= tr_ctx
->pipe
;
919 struct pipe_texture
*unwrapped_textures
[PIPE_MAX_SAMPLERS
];
922 for(i
= 0; i
< num_textures
; ++i
)
923 unwrapped_textures
[i
] = trace_texture_unwrap(tr_ctx
, textures
[i
]);
924 textures
= unwrapped_textures
;
926 trace_dump_call_begin("pipe_context", "set_sampler_textures");
928 trace_dump_arg(ptr
, pipe
);
929 trace_dump_arg(uint
, num_textures
);
930 trace_dump_arg_array(ptr
, textures
, num_textures
);
932 pipe
->set_sampler_textures(pipe
, num_textures
, textures
);;
934 trace_dump_call_end();
939 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
940 unsigned num_buffers
,
941 const struct pipe_vertex_buffer
*buffers
)
943 struct trace_context
*tr_ctx
= trace_context(_pipe
);
944 struct pipe_context
*pipe
= tr_ctx
->pipe
;
947 for(i
= 0; i
< num_buffers
; ++i
)
948 trace_screen_user_buffer_update(_pipe
->screen
, buffers
[i
].buffer
);
950 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
952 trace_dump_arg(ptr
, pipe
);
953 trace_dump_arg(uint
, num_buffers
);
955 trace_dump_arg_begin("buffers");
956 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
957 trace_dump_arg_end();
960 struct pipe_vertex_buffer
*_buffers
= malloc(num_buffers
* sizeof(*_buffers
));
961 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
962 for (i
= 0; i
< num_buffers
; i
++)
963 _buffers
[i
].buffer
= trace_buffer_unwrap(tr_ctx
, buffers
[i
].buffer
);
964 pipe
->set_vertex_buffers(pipe
, num_buffers
, _buffers
);
967 pipe
->set_vertex_buffers(pipe
, num_buffers
, NULL
);
970 trace_dump_call_end();
975 trace_context_set_vertex_elements(struct pipe_context
*_pipe
,
976 unsigned num_elements
,
977 const struct pipe_vertex_element
*elements
)
979 struct trace_context
*tr_ctx
= trace_context(_pipe
);
980 struct pipe_context
*pipe
= tr_ctx
->pipe
;
982 trace_dump_call_begin("pipe_context", "set_vertex_elements");
984 trace_dump_arg(ptr
, pipe
);
985 trace_dump_arg(uint
, num_elements
);
987 trace_dump_arg_begin("elements");
988 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
989 trace_dump_arg_end();
991 pipe
->set_vertex_elements(pipe
, num_elements
, elements
);;
993 trace_dump_call_end();
998 trace_context_surface_copy(struct pipe_context
*_pipe
,
999 struct pipe_surface
*dest
,
1000 unsigned destx
, unsigned desty
,
1001 struct pipe_surface
*src
,
1002 unsigned srcx
, unsigned srcy
,
1003 unsigned width
, unsigned height
)
1005 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1006 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1008 dest
= trace_surface_unwrap(tr_ctx
, dest
);
1009 src
= trace_surface_unwrap(tr_ctx
, src
);
1011 trace_dump_call_begin("pipe_context", "surface_copy");
1013 trace_dump_arg(ptr
, pipe
);
1014 trace_dump_arg(ptr
, dest
);
1015 trace_dump_arg(uint
, destx
);
1016 trace_dump_arg(uint
, desty
);
1017 trace_dump_arg(ptr
, src
);
1018 trace_dump_arg(uint
, srcx
);
1019 trace_dump_arg(uint
, srcy
);
1020 trace_dump_arg(uint
, width
);
1021 trace_dump_arg(uint
, height
);
1023 pipe
->surface_copy(pipe
,
1025 src
, srcx
, srcy
, width
, height
);
1027 trace_dump_call_end();
1032 trace_context_surface_fill(struct pipe_context
*_pipe
,
1033 struct pipe_surface
*dst
,
1034 unsigned dstx
, unsigned dsty
,
1035 unsigned width
, unsigned height
,
1038 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1039 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1041 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1043 trace_dump_call_begin("pipe_context", "surface_fill");
1045 trace_dump_arg(ptr
, pipe
);
1046 trace_dump_arg(ptr
, dst
);
1047 trace_dump_arg(uint
, dstx
);
1048 trace_dump_arg(uint
, dsty
);
1049 trace_dump_arg(uint
, width
);
1050 trace_dump_arg(uint
, height
);
1052 pipe
->surface_fill(pipe
, dst
, dstx
, dsty
, width
, height
, value
);;
1054 trace_dump_call_end();
1059 trace_context_clear(struct pipe_context
*_pipe
,
1065 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1066 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1068 trace_dump_call_begin("pipe_context", "clear");
1070 trace_dump_arg(ptr
, pipe
);
1071 trace_dump_arg(uint
, buffers
);
1072 trace_dump_arg_array(float, rgba
, 4);
1073 trace_dump_arg(float, depth
);
1074 trace_dump_arg(uint
, stencil
);
1076 pipe
->clear(pipe
, buffers
, rgba
, depth
, stencil
);
1078 trace_dump_call_end();
1083 trace_context_flush(struct pipe_context
*_pipe
,
1085 struct pipe_fence_handle
**fence
)
1087 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1088 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1090 trace_dump_call_begin("pipe_context", "flush");
1092 trace_dump_arg(ptr
, pipe
);
1093 trace_dump_arg(uint
, flags
);
1095 pipe
->flush(pipe
, flags
, fence
);;
1098 trace_dump_ret(ptr
, *fence
);
1100 trace_dump_call_end();
1105 trace_context_destroy(struct pipe_context
*_pipe
)
1107 struct trace_screen
*tr_scr
= trace_screen(_pipe
->screen
);
1108 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1109 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1111 trace_dump_call_begin("pipe_context", "destroy");
1112 trace_dump_arg(ptr
, pipe
);
1113 trace_dump_call_end();
1115 trace_screen_remove_from_list(tr_scr
, contexts
, tr_ctx
);
1117 pipe
->destroy(pipe
);
1123 trace_is_texture_referenced( struct pipe_context
*_pipe
,
1124 struct pipe_texture
*_texture
,
1125 unsigned face
, unsigned level
)
1127 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1128 struct trace_texture
*tr_tex
= trace_texture(_texture
);
1129 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1130 struct pipe_texture
*texture
= tr_tex
->texture
;
1131 unsigned int referenced
;
1133 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1134 trace_dump_arg(ptr
, pipe
);
1135 trace_dump_arg(ptr
, texture
);
1136 trace_dump_arg(uint
, face
);
1137 trace_dump_arg(uint
, level
);
1139 referenced
= pipe
->is_texture_referenced(pipe
, texture
, face
, level
);
1141 trace_dump_ret(uint
, referenced
);
1142 trace_dump_call_end();
1148 trace_is_buffer_referenced( struct pipe_context
*_pipe
,
1149 struct pipe_buffer
*_buf
)
1151 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1152 struct trace_buffer
*tr_buf
= trace_buffer(_buf
);
1153 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1154 struct pipe_buffer
*buf
= tr_buf
->buffer
;
1155 unsigned int referenced
;
1157 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1158 trace_dump_arg(ptr
, pipe
);
1159 trace_dump_arg(ptr
, buf
);
1161 referenced
= pipe
->is_buffer_referenced(pipe
, buf
);
1163 trace_dump_ret(uint
, referenced
);
1164 trace_dump_call_end();
1169 static const struct debug_named_value rbug_blocker_flags
[] = {
1175 struct pipe_context
*
1176 trace_context_create(struct pipe_screen
*_screen
,
1177 struct pipe_context
*pipe
)
1179 struct trace_screen
*tr_scr
;
1180 struct trace_context
*tr_ctx
;
1181 struct pipe_screen
*screen
;
1186 if(!trace_enabled())
1189 tr_scr
= trace_screen(_screen
);
1190 screen
= tr_scr
->screen
;
1192 tr_ctx
= CALLOC_STRUCT(trace_context
);
1196 tr_ctx
->draw_blocker
= debug_get_flags_option("RBUG_BLOCK",
1199 pipe_mutex_init(tr_ctx
->draw_mutex
);
1200 pipe_condvar_init(tr_ctx
->draw_cond
);
1201 pipe_mutex_init(tr_ctx
->list_mutex
);
1202 make_empty_list(&tr_ctx
->shaders
);
1204 tr_ctx
->base
.winsys
= _screen
->winsys
;
1205 tr_ctx
->base
.screen
= _screen
;
1206 tr_ctx
->base
.destroy
= trace_context_destroy
;
1207 tr_ctx
->base
.set_edgeflags
= trace_context_set_edgeflags
;
1208 tr_ctx
->base
.draw_arrays
= trace_context_draw_arrays
;
1209 tr_ctx
->base
.draw_elements
= trace_context_draw_elements
;
1210 tr_ctx
->base
.draw_range_elements
= trace_context_draw_range_elements
;
1211 tr_ctx
->base
.create_query
= trace_context_create_query
;
1212 tr_ctx
->base
.destroy_query
= trace_context_destroy_query
;
1213 tr_ctx
->base
.begin_query
= trace_context_begin_query
;
1214 tr_ctx
->base
.end_query
= trace_context_end_query
;
1215 tr_ctx
->base
.get_query_result
= trace_context_get_query_result
;
1216 tr_ctx
->base
.create_blend_state
= trace_context_create_blend_state
;
1217 tr_ctx
->base
.bind_blend_state
= trace_context_bind_blend_state
;
1218 tr_ctx
->base
.delete_blend_state
= trace_context_delete_blend_state
;
1219 tr_ctx
->base
.create_sampler_state
= trace_context_create_sampler_state
;
1220 tr_ctx
->base
.bind_sampler_states
= trace_context_bind_sampler_states
;
1221 tr_ctx
->base
.delete_sampler_state
= trace_context_delete_sampler_state
;
1222 tr_ctx
->base
.create_rasterizer_state
= trace_context_create_rasterizer_state
;
1223 tr_ctx
->base
.bind_rasterizer_state
= trace_context_bind_rasterizer_state
;
1224 tr_ctx
->base
.delete_rasterizer_state
= trace_context_delete_rasterizer_state
;
1225 tr_ctx
->base
.create_depth_stencil_alpha_state
= trace_context_create_depth_stencil_alpha_state
;
1226 tr_ctx
->base
.bind_depth_stencil_alpha_state
= trace_context_bind_depth_stencil_alpha_state
;
1227 tr_ctx
->base
.delete_depth_stencil_alpha_state
= trace_context_delete_depth_stencil_alpha_state
;
1228 tr_ctx
->base
.create_fs_state
= trace_context_create_fs_state
;
1229 tr_ctx
->base
.bind_fs_state
= trace_context_bind_fs_state
;
1230 tr_ctx
->base
.delete_fs_state
= trace_context_delete_fs_state
;
1231 tr_ctx
->base
.create_vs_state
= trace_context_create_vs_state
;
1232 tr_ctx
->base
.bind_vs_state
= trace_context_bind_vs_state
;
1233 tr_ctx
->base
.delete_vs_state
= trace_context_delete_vs_state
;
1234 tr_ctx
->base
.set_blend_color
= trace_context_set_blend_color
;
1235 tr_ctx
->base
.set_clip_state
= trace_context_set_clip_state
;
1236 tr_ctx
->base
.set_constant_buffer
= trace_context_set_constant_buffer
;
1237 tr_ctx
->base
.set_framebuffer_state
= trace_context_set_framebuffer_state
;
1238 tr_ctx
->base
.set_polygon_stipple
= trace_context_set_polygon_stipple
;
1239 tr_ctx
->base
.set_scissor_state
= trace_context_set_scissor_state
;
1240 tr_ctx
->base
.set_viewport_state
= trace_context_set_viewport_state
;
1241 tr_ctx
->base
.set_sampler_textures
= trace_context_set_sampler_textures
;
1242 tr_ctx
->base
.set_vertex_buffers
= trace_context_set_vertex_buffers
;
1243 tr_ctx
->base
.set_vertex_elements
= trace_context_set_vertex_elements
;
1244 tr_ctx
->base
.surface_copy
= trace_context_surface_copy
;
1245 tr_ctx
->base
.surface_fill
= trace_context_surface_fill
;
1246 tr_ctx
->base
.clear
= trace_context_clear
;
1247 tr_ctx
->base
.flush
= trace_context_flush
;
1248 tr_ctx
->base
.is_texture_referenced
= trace_is_texture_referenced
;
1249 tr_ctx
->base
.is_buffer_referenced
= trace_is_buffer_referenced
;
1251 tr_ctx
->pipe
= pipe
;
1253 trace_dump_call_begin("", "pipe_context_create");
1254 trace_dump_arg(ptr
, screen
);
1255 trace_dump_ret(ptr
, pipe
);
1256 trace_dump_call_end();
1258 trace_screen_add_to_list(tr_scr
, contexts
, tr_ctx
);
1260 return &tr_ctx
->base
;