1 /**************************************************************************
3 * Copyright 2008 VMware, Inc.
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 VMWARE 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_inlines.h"
29 #include "util/u_memory.h"
30 #include "util/simple_list.h"
32 #include "pipe/p_format.h"
33 #include "pipe/p_screen.h"
36 #include "tr_dump_defines.h"
37 #include "tr_dump_state.h"
38 #include "tr_public.h"
39 #include "tr_screen.h"
40 #include "tr_texture.h"
41 #include "tr_context.h"
48 struct pipe_query
*query
;
52 static inline struct trace_query
*
53 trace_query(struct pipe_query
*query
)
55 return (struct trace_query
*)query
;
59 static inline struct pipe_query
*
60 trace_query_unwrap(struct pipe_query
*query
)
63 return trace_query(query
)->query
;
70 static inline struct pipe_resource
*
71 trace_resource_unwrap(struct trace_context
*tr_ctx
,
72 struct pipe_resource
*resource
)
74 struct trace_resource
*tr_res
;
79 tr_res
= trace_resource(resource
);
81 assert(tr_res
->resource
);
82 return tr_res
->resource
;
86 static inline struct pipe_surface
*
87 trace_surface_unwrap(struct trace_context
*tr_ctx
,
88 struct pipe_surface
*surface
)
90 struct trace_screen
*tr_scr
= trace_screen(tr_ctx
->base
.screen
);
91 struct trace_surface
*tr_surf
;
96 assert(surface
->texture
);
97 if (!surface
->texture
)
100 tr_surf
= trace_surface(surface
);
102 assert(tr_surf
->surface
);
103 assert(tr_surf
->surface
->texture
->screen
== tr_scr
->screen
);
105 return tr_surf
->surface
;
110 trace_context_draw_vbo(struct pipe_context
*_pipe
,
111 const struct pipe_draw_info
*info
)
113 struct trace_context
*tr_ctx
= trace_context(_pipe
);
114 struct pipe_context
*pipe
= tr_ctx
->pipe
;
116 trace_dump_call_begin("pipe_context", "draw_vbo");
118 trace_dump_arg(ptr
, pipe
);
119 trace_dump_arg(draw_info
, info
);
121 trace_dump_trace_flush();
123 if (info
->indirect
) {
124 struct pipe_draw_info _info
;
126 memcpy(&_info
, info
, sizeof(_info
));
127 _info
.indirect
= trace_resource_unwrap(tr_ctx
, _info
.indirect
);
128 _info
.indirect_params
= trace_resource_unwrap(tr_ctx
,
129 _info
.indirect_params
);
130 pipe
->draw_vbo(pipe
, &_info
);
132 pipe
->draw_vbo(pipe
, info
);
135 trace_dump_call_end();
139 static struct pipe_query
*
140 trace_context_create_query(struct pipe_context
*_pipe
,
144 struct trace_context
*tr_ctx
= trace_context(_pipe
);
145 struct pipe_context
*pipe
= tr_ctx
->pipe
;
146 struct pipe_query
*query
;
148 trace_dump_call_begin("pipe_context", "create_query");
150 trace_dump_arg(ptr
, pipe
);
151 trace_dump_arg(query_type
, query_type
);
152 trace_dump_arg(int, index
);
154 query
= pipe
->create_query(pipe
, query_type
, index
);
156 trace_dump_ret(ptr
, query
);
158 trace_dump_call_end();
160 /* Wrap query object. */
162 struct trace_query
*tr_query
= CALLOC_STRUCT(trace_query
);
164 tr_query
->type
= query_type
;
165 tr_query
->query
= query
;
166 query
= (struct pipe_query
*)tr_query
;
168 pipe
->destroy_query(pipe
, query
);
178 trace_context_destroy_query(struct pipe_context
*_pipe
,
179 struct pipe_query
*_query
)
181 struct trace_context
*tr_ctx
= trace_context(_pipe
);
182 struct pipe_context
*pipe
= tr_ctx
->pipe
;
183 struct trace_query
*tr_query
= trace_query(_query
);
184 struct pipe_query
*query
= tr_query
->query
;
188 trace_dump_call_begin("pipe_context", "destroy_query");
190 trace_dump_arg(ptr
, pipe
);
191 trace_dump_arg(ptr
, query
);
193 pipe
->destroy_query(pipe
, query
);
195 trace_dump_call_end();
200 trace_context_begin_query(struct pipe_context
*_pipe
,
201 struct pipe_query
*query
)
203 struct trace_context
*tr_ctx
= trace_context(_pipe
);
204 struct pipe_context
*pipe
= tr_ctx
->pipe
;
207 query
= trace_query_unwrap(query
);
209 trace_dump_call_begin("pipe_context", "begin_query");
211 trace_dump_arg(ptr
, pipe
);
212 trace_dump_arg(ptr
, query
);
214 ret
= pipe
->begin_query(pipe
, query
);
216 trace_dump_call_end();
222 trace_context_end_query(struct pipe_context
*_pipe
,
223 struct pipe_query
*query
)
225 struct trace_context
*tr_ctx
= trace_context(_pipe
);
226 struct pipe_context
*pipe
= tr_ctx
->pipe
;
229 query
= trace_query_unwrap(query
);
231 trace_dump_call_begin("pipe_context", "end_query");
233 trace_dump_arg(ptr
, pipe
);
234 trace_dump_arg(ptr
, query
);
236 ret
= pipe
->end_query(pipe
, query
);
238 trace_dump_call_end();
244 trace_context_get_query_result(struct pipe_context
*_pipe
,
245 struct pipe_query
*_query
,
247 union pipe_query_result
*result
)
249 struct trace_context
*tr_ctx
= trace_context(_pipe
);
250 struct pipe_context
*pipe
= tr_ctx
->pipe
;
251 struct trace_query
*tr_query
= trace_query(_query
);
252 struct pipe_query
*query
= tr_query
->query
;
255 trace_dump_call_begin("pipe_context", "get_query_result");
257 trace_dump_arg(ptr
, pipe
);
258 trace_dump_arg(ptr
, query
);
260 ret
= pipe
->get_query_result(pipe
, query
, wait
, result
);
262 trace_dump_arg_begin("result");
264 trace_dump_query_result(tr_query
->type
, result
);
268 trace_dump_arg_end();
270 trace_dump_ret(bool, ret
);
272 trace_dump_call_end();
279 trace_context_set_active_query_state(struct pipe_context
*_pipe
,
282 struct trace_context
*tr_ctx
= trace_context(_pipe
);
283 struct pipe_context
*pipe
= tr_ctx
->pipe
;
285 trace_dump_call_begin("pipe_context", "set_active_query_state");
287 trace_dump_arg(ptr
, pipe
);
288 trace_dump_arg(bool, enable
);
290 pipe
->set_active_query_state(pipe
, enable
);
292 trace_dump_call_end();
297 trace_context_create_blend_state(struct pipe_context
*_pipe
,
298 const struct pipe_blend_state
*state
)
300 struct trace_context
*tr_ctx
= trace_context(_pipe
);
301 struct pipe_context
*pipe
= tr_ctx
->pipe
;
304 trace_dump_call_begin("pipe_context", "create_blend_state");
306 trace_dump_arg(ptr
, pipe
);
307 trace_dump_arg(blend_state
, state
);
309 result
= pipe
->create_blend_state(pipe
, state
);
311 trace_dump_ret(ptr
, result
);
313 trace_dump_call_end();
320 trace_context_bind_blend_state(struct pipe_context
*_pipe
,
323 struct trace_context
*tr_ctx
= trace_context(_pipe
);
324 struct pipe_context
*pipe
= tr_ctx
->pipe
;
326 trace_dump_call_begin("pipe_context", "bind_blend_state");
328 trace_dump_arg(ptr
, pipe
);
329 trace_dump_arg(ptr
, state
);
331 pipe
->bind_blend_state(pipe
, state
);
333 trace_dump_call_end();
338 trace_context_delete_blend_state(struct pipe_context
*_pipe
,
341 struct trace_context
*tr_ctx
= trace_context(_pipe
);
342 struct pipe_context
*pipe
= tr_ctx
->pipe
;
344 trace_dump_call_begin("pipe_context", "delete_blend_state");
346 trace_dump_arg(ptr
, pipe
);
347 trace_dump_arg(ptr
, state
);
349 pipe
->delete_blend_state(pipe
, state
);
351 trace_dump_call_end();
356 trace_context_create_sampler_state(struct pipe_context
*_pipe
,
357 const struct pipe_sampler_state
*state
)
359 struct trace_context
*tr_ctx
= trace_context(_pipe
);
360 struct pipe_context
*pipe
= tr_ctx
->pipe
;
363 trace_dump_call_begin("pipe_context", "create_sampler_state");
365 trace_dump_arg(ptr
, pipe
);
366 trace_dump_arg(sampler_state
, state
);
368 result
= pipe
->create_sampler_state(pipe
, state
);
370 trace_dump_ret(ptr
, result
);
372 trace_dump_call_end();
379 trace_context_bind_sampler_states(struct pipe_context
*_pipe
,
385 struct trace_context
*tr_ctx
= trace_context(_pipe
);
386 struct pipe_context
*pipe
= tr_ctx
->pipe
;
388 /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
391 trace_dump_call_begin("pipe_context", "bind_sampler_states");
393 trace_dump_arg(ptr
, pipe
);
394 trace_dump_arg(uint
, shader
);
395 trace_dump_arg(uint
, start
);
396 trace_dump_arg(uint
, num_states
);
397 trace_dump_arg_array(ptr
, states
, num_states
);
399 pipe
->bind_sampler_states(pipe
, shader
, start
, num_states
, states
);
401 trace_dump_call_end();
406 trace_context_delete_sampler_state(struct pipe_context
*_pipe
,
409 struct trace_context
*tr_ctx
= trace_context(_pipe
);
410 struct pipe_context
*pipe
= tr_ctx
->pipe
;
412 trace_dump_call_begin("pipe_context", "delete_sampler_state");
414 trace_dump_arg(ptr
, pipe
);
415 trace_dump_arg(ptr
, state
);
417 pipe
->delete_sampler_state(pipe
, state
);
419 trace_dump_call_end();
424 trace_context_create_rasterizer_state(struct pipe_context
*_pipe
,
425 const struct pipe_rasterizer_state
*state
)
427 struct trace_context
*tr_ctx
= trace_context(_pipe
);
428 struct pipe_context
*pipe
= tr_ctx
->pipe
;
431 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
433 trace_dump_arg(ptr
, pipe
);
434 trace_dump_arg(rasterizer_state
, state
);
436 result
= pipe
->create_rasterizer_state(pipe
, state
);
438 trace_dump_ret(ptr
, result
);
440 trace_dump_call_end();
447 trace_context_bind_rasterizer_state(struct pipe_context
*_pipe
,
450 struct trace_context
*tr_ctx
= trace_context(_pipe
);
451 struct pipe_context
*pipe
= tr_ctx
->pipe
;
453 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
455 trace_dump_arg(ptr
, pipe
);
456 trace_dump_arg(ptr
, state
);
458 pipe
->bind_rasterizer_state(pipe
, state
);
460 trace_dump_call_end();
465 trace_context_delete_rasterizer_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_rasterizer_state");
473 trace_dump_arg(ptr
, pipe
);
474 trace_dump_arg(ptr
, state
);
476 pipe
->delete_rasterizer_state(pipe
, state
);
478 trace_dump_call_end();
483 trace_context_create_depth_stencil_alpha_state(struct pipe_context
*_pipe
,
484 const struct pipe_depth_stencil_alpha_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_depth_stencil_alpha_state");
492 result
= pipe
->create_depth_stencil_alpha_state(pipe
, state
);
494 trace_dump_arg(ptr
, pipe
);
495 trace_dump_arg(depth_stencil_alpha_state
, state
);
497 trace_dump_ret(ptr
, result
);
499 trace_dump_call_end();
506 trace_context_bind_depth_stencil_alpha_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_depth_stencil_alpha_state");
514 trace_dump_arg(ptr
, pipe
);
515 trace_dump_arg(ptr
, state
);
517 pipe
->bind_depth_stencil_alpha_state(pipe
, state
);
519 trace_dump_call_end();
524 trace_context_delete_depth_stencil_alpha_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_depth_stencil_alpha_state");
532 trace_dump_arg(ptr
, pipe
);
533 trace_dump_arg(ptr
, state
);
535 pipe
->delete_depth_stencil_alpha_state(pipe
, state
);
537 trace_dump_call_end();
541 #define TRACE_SHADER_STATE(shader_type) \
543 trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \
544 const struct pipe_shader_state *state) \
546 struct trace_context *tr_ctx = trace_context(_pipe); \
547 struct pipe_context *pipe = tr_ctx->pipe; \
549 trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \
550 trace_dump_arg(ptr, pipe); \
551 trace_dump_arg(shader_state, state); \
552 result = pipe->create_##shader_type##_state(pipe, state); \
553 trace_dump_ret(ptr, result); \
554 trace_dump_call_end(); \
559 trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \
562 struct trace_context *tr_ctx = trace_context(_pipe); \
563 struct pipe_context *pipe = tr_ctx->pipe; \
564 trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \
565 trace_dump_arg(ptr, pipe); \
566 trace_dump_arg(ptr, state); \
567 pipe->bind_##shader_type##_state(pipe, state); \
568 trace_dump_call_end(); \
572 trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \
575 struct trace_context *tr_ctx = trace_context(_pipe); \
576 struct pipe_context *pipe = tr_ctx->pipe; \
577 trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \
578 trace_dump_arg(ptr, pipe); \
579 trace_dump_arg(ptr, state); \
580 pipe->delete_##shader_type##_state(pipe, state); \
581 trace_dump_call_end(); \
584 TRACE_SHADER_STATE(fs
)
585 TRACE_SHADER_STATE(vs
)
586 TRACE_SHADER_STATE(gs
)
587 TRACE_SHADER_STATE(tcs
)
588 TRACE_SHADER_STATE(tes
)
590 #undef TRACE_SHADER_STATE
594 trace_context_create_compute_state(struct pipe_context
*_pipe
,
595 const struct pipe_compute_state
*state
)
597 struct trace_context
*tr_ctx
= trace_context(_pipe
);
598 struct pipe_context
*pipe
= tr_ctx
->pipe
;
601 trace_dump_call_begin("pipe_context", "create_compute_state");
602 trace_dump_arg(ptr
, pipe
);
603 trace_dump_arg(compute_state
, state
);
604 result
= pipe
->create_compute_state(pipe
, state
);
605 trace_dump_ret(ptr
, result
);
606 trace_dump_call_end();
611 trace_context_bind_compute_state(struct pipe_context
*_pipe
,
614 struct trace_context
*tr_ctx
= trace_context(_pipe
);
615 struct pipe_context
*pipe
= tr_ctx
->pipe
;
617 trace_dump_call_begin("pipe_context", "bind_compute_state");
618 trace_dump_arg(ptr
, pipe
);
619 trace_dump_arg(ptr
, state
);
620 pipe
->bind_compute_state(pipe
, state
);
621 trace_dump_call_end();
625 trace_context_delete_compute_state(struct pipe_context
*_pipe
,
628 struct trace_context
*tr_ctx
= trace_context(_pipe
);
629 struct pipe_context
*pipe
= tr_ctx
->pipe
;
631 trace_dump_call_begin("pipe_context", "delete_compute_state");
632 trace_dump_arg(ptr
, pipe
);
633 trace_dump_arg(ptr
, state
);
634 pipe
->delete_compute_state(pipe
, state
);
635 trace_dump_call_end();
639 trace_context_create_vertex_elements_state(struct pipe_context
*_pipe
,
640 unsigned num_elements
,
641 const struct pipe_vertex_element
*elements
)
643 struct trace_context
*tr_ctx
= trace_context(_pipe
);
644 struct pipe_context
*pipe
= tr_ctx
->pipe
;
647 trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
649 trace_dump_arg(ptr
, pipe
);
650 trace_dump_arg(uint
, num_elements
);
652 trace_dump_arg_begin("elements");
653 trace_dump_struct_array(vertex_element
, elements
, num_elements
);
654 trace_dump_arg_end();
656 result
= pipe
->create_vertex_elements_state(pipe
, num_elements
, elements
);
658 trace_dump_ret(ptr
, result
);
660 trace_dump_call_end();
667 trace_context_bind_vertex_elements_state(struct pipe_context
*_pipe
,
670 struct trace_context
*tr_ctx
= trace_context(_pipe
);
671 struct pipe_context
*pipe
= tr_ctx
->pipe
;
673 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
675 trace_dump_arg(ptr
, pipe
);
676 trace_dump_arg(ptr
, state
);
678 pipe
->bind_vertex_elements_state(pipe
, state
);
680 trace_dump_call_end();
685 trace_context_delete_vertex_elements_state(struct pipe_context
*_pipe
,
688 struct trace_context
*tr_ctx
= trace_context(_pipe
);
689 struct pipe_context
*pipe
= tr_ctx
->pipe
;
691 trace_dump_call_begin("pipe_context", "delete_vertex_elements_state");
693 trace_dump_arg(ptr
, pipe
);
694 trace_dump_arg(ptr
, state
);
696 pipe
->delete_vertex_elements_state(pipe
, state
);
698 trace_dump_call_end();
703 trace_context_set_blend_color(struct pipe_context
*_pipe
,
704 const struct pipe_blend_color
*state
)
706 struct trace_context
*tr_ctx
= trace_context(_pipe
);
707 struct pipe_context
*pipe
= tr_ctx
->pipe
;
709 trace_dump_call_begin("pipe_context", "set_blend_color");
711 trace_dump_arg(ptr
, pipe
);
712 trace_dump_arg(blend_color
, state
);
714 pipe
->set_blend_color(pipe
, state
);
716 trace_dump_call_end();
721 trace_context_set_stencil_ref(struct pipe_context
*_pipe
,
722 const struct pipe_stencil_ref
*state
)
724 struct trace_context
*tr_ctx
= trace_context(_pipe
);
725 struct pipe_context
*pipe
= tr_ctx
->pipe
;
727 trace_dump_call_begin("pipe_context", "set_stencil_ref");
729 trace_dump_arg(ptr
, pipe
);
730 trace_dump_arg(stencil_ref
, state
);
732 pipe
->set_stencil_ref(pipe
, state
);
734 trace_dump_call_end();
739 trace_context_set_clip_state(struct pipe_context
*_pipe
,
740 const struct pipe_clip_state
*state
)
742 struct trace_context
*tr_ctx
= trace_context(_pipe
);
743 struct pipe_context
*pipe
= tr_ctx
->pipe
;
745 trace_dump_call_begin("pipe_context", "set_clip_state");
747 trace_dump_arg(ptr
, pipe
);
748 trace_dump_arg(clip_state
, state
);
750 pipe
->set_clip_state(pipe
, state
);
752 trace_dump_call_end();
756 trace_context_set_sample_mask(struct pipe_context
*_pipe
,
757 unsigned sample_mask
)
759 struct trace_context
*tr_ctx
= trace_context(_pipe
);
760 struct pipe_context
*pipe
= tr_ctx
->pipe
;
762 trace_dump_call_begin("pipe_context", "set_sample_mask");
764 trace_dump_arg(ptr
, pipe
);
765 trace_dump_arg(uint
, sample_mask
);
767 pipe
->set_sample_mask(pipe
, sample_mask
);
769 trace_dump_call_end();
773 trace_context_set_constant_buffer(struct pipe_context
*_pipe
,
774 uint shader
, uint index
,
775 const struct pipe_constant_buffer
*constant_buffer
)
777 struct trace_context
*tr_ctx
= trace_context(_pipe
);
778 struct pipe_context
*pipe
= tr_ctx
->pipe
;
779 struct pipe_constant_buffer cb
;
781 if (constant_buffer
) {
782 cb
= *constant_buffer
;
783 cb
.buffer
= trace_resource_unwrap(tr_ctx
, constant_buffer
->buffer
);
784 constant_buffer
= &cb
;
787 trace_dump_call_begin("pipe_context", "set_constant_buffer");
789 trace_dump_arg(ptr
, pipe
);
790 trace_dump_arg(uint
, shader
);
791 trace_dump_arg(uint
, index
);
792 trace_dump_arg(constant_buffer
, constant_buffer
);
794 pipe
->set_constant_buffer(pipe
, shader
, index
, constant_buffer
);
796 trace_dump_call_end();
801 trace_context_set_framebuffer_state(struct pipe_context
*_pipe
,
802 const struct pipe_framebuffer_state
*state
)
804 struct trace_context
*tr_ctx
= trace_context(_pipe
);
805 struct pipe_context
*pipe
= tr_ctx
->pipe
;
806 struct pipe_framebuffer_state unwrapped_state
;
810 /* Unwrap the input state */
811 memcpy(&unwrapped_state
, state
, sizeof(unwrapped_state
));
812 for (i
= 0; i
< state
->nr_cbufs
; ++i
)
813 unwrapped_state
.cbufs
[i
] = trace_surface_unwrap(tr_ctx
, state
->cbufs
[i
]);
814 for (i
= state
->nr_cbufs
; i
< PIPE_MAX_COLOR_BUFS
; ++i
)
815 unwrapped_state
.cbufs
[i
] = NULL
;
816 unwrapped_state
.zsbuf
= trace_surface_unwrap(tr_ctx
, state
->zsbuf
);
817 state
= &unwrapped_state
;
819 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
821 trace_dump_arg(ptr
, pipe
);
822 trace_dump_arg(framebuffer_state
, state
);
824 pipe
->set_framebuffer_state(pipe
, state
);
826 trace_dump_call_end();
831 trace_context_set_polygon_stipple(struct pipe_context
*_pipe
,
832 const struct pipe_poly_stipple
*state
)
834 struct trace_context
*tr_ctx
= trace_context(_pipe
);
835 struct pipe_context
*pipe
= tr_ctx
->pipe
;
837 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
839 trace_dump_arg(ptr
, pipe
);
840 trace_dump_arg(poly_stipple
, state
);
842 pipe
->set_polygon_stipple(pipe
, state
);
844 trace_dump_call_end();
849 trace_context_set_scissor_states(struct pipe_context
*_pipe
,
851 unsigned num_scissors
,
852 const struct pipe_scissor_state
*states
)
854 struct trace_context
*tr_ctx
= trace_context(_pipe
);
855 struct pipe_context
*pipe
= tr_ctx
->pipe
;
857 trace_dump_call_begin("pipe_context", "set_scissor_states");
859 trace_dump_arg(ptr
, pipe
);
860 trace_dump_arg(uint
, start_slot
);
861 trace_dump_arg(uint
, num_scissors
);
862 trace_dump_arg(scissor_state
, states
);
864 pipe
->set_scissor_states(pipe
, start_slot
, num_scissors
, states
);
866 trace_dump_call_end();
871 trace_context_set_viewport_states(struct pipe_context
*_pipe
,
873 unsigned num_viewports
,
874 const struct pipe_viewport_state
*states
)
876 struct trace_context
*tr_ctx
= trace_context(_pipe
);
877 struct pipe_context
*pipe
= tr_ctx
->pipe
;
879 trace_dump_call_begin("pipe_context", "set_viewport_states");
881 trace_dump_arg(ptr
, pipe
);
882 trace_dump_arg(uint
, start_slot
);
883 trace_dump_arg(uint
, num_viewports
);
884 trace_dump_arg(viewport_state
, states
);
886 pipe
->set_viewport_states(pipe
, start_slot
, num_viewports
, states
);
888 trace_dump_call_end();
892 static struct pipe_sampler_view
*
893 trace_context_create_sampler_view(struct pipe_context
*_pipe
,
894 struct pipe_resource
*_resource
,
895 const struct pipe_sampler_view
*templ
)
897 struct trace_context
*tr_ctx
= trace_context(_pipe
);
898 struct trace_resource
*tr_res
= trace_resource(_resource
);
899 struct pipe_context
*pipe
= tr_ctx
->pipe
;
900 struct pipe_resource
*resource
= tr_res
->resource
;
901 struct pipe_sampler_view
*result
;
902 struct trace_sampler_view
*tr_view
;
904 trace_dump_call_begin("pipe_context", "create_sampler_view");
906 trace_dump_arg(ptr
, pipe
);
907 trace_dump_arg(ptr
, resource
);
909 trace_dump_arg_begin("templ");
910 trace_dump_sampler_view_template(templ
, resource
->target
);
911 trace_dump_arg_end();
913 result
= pipe
->create_sampler_view(pipe
, resource
, templ
);
915 trace_dump_ret(ptr
, result
);
917 trace_dump_call_end();
920 * Wrap pipe_sampler_view
922 tr_view
= CALLOC_STRUCT(trace_sampler_view
);
923 tr_view
->base
= *templ
;
924 tr_view
->base
.reference
.count
= 1;
925 tr_view
->base
.texture
= NULL
;
926 pipe_resource_reference(&tr_view
->base
.texture
, _resource
);
927 tr_view
->base
.context
= _pipe
;
928 tr_view
->sampler_view
= result
;
929 result
= &tr_view
->base
;
936 trace_context_sampler_view_destroy(struct pipe_context
*_pipe
,
937 struct pipe_sampler_view
*_view
)
939 struct trace_context
*tr_ctx
= trace_context(_pipe
);
940 struct trace_sampler_view
*tr_view
= trace_sampler_view(_view
);
941 struct pipe_context
*pipe
= tr_ctx
->pipe
;
942 struct pipe_sampler_view
*view
= tr_view
->sampler_view
;
944 assert(_view
->context
== _pipe
);
946 trace_dump_call_begin("pipe_context", "sampler_view_destroy");
948 trace_dump_arg(ptr
, pipe
);
949 trace_dump_arg(ptr
, view
);
951 pipe_sampler_view_reference(&tr_view
->sampler_view
, NULL
);
953 trace_dump_call_end();
955 pipe_resource_reference(&_view
->texture
, NULL
);
959 /********************************************************************
964 static struct pipe_surface
*
965 trace_context_create_surface(struct pipe_context
*_pipe
,
966 struct pipe_resource
*_resource
,
967 const struct pipe_surface
*surf_tmpl
)
969 struct trace_context
*tr_ctx
= trace_context(_pipe
);
970 struct trace_resource
*tr_res
= trace_resource(_resource
);
971 struct pipe_context
*pipe
= tr_ctx
->pipe
;
972 struct pipe_resource
*resource
= tr_res
->resource
;
973 struct pipe_surface
*result
= NULL
;
975 trace_dump_call_begin("pipe_context", "create_surface");
977 trace_dump_arg(ptr
, pipe
);
978 trace_dump_arg(ptr
, resource
);
980 trace_dump_arg_begin("surf_tmpl");
981 trace_dump_surface_template(surf_tmpl
, resource
->target
);
982 trace_dump_arg_end();
985 result
= pipe
->create_surface(pipe
, resource
, surf_tmpl
);
987 trace_dump_ret(ptr
, result
);
989 trace_dump_call_end();
991 result
= trace_surf_create(tr_ctx
, tr_res
, result
);
998 trace_context_surface_destroy(struct pipe_context
*_pipe
,
999 struct pipe_surface
*_surface
)
1001 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1002 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1003 struct trace_surface
*tr_surf
= trace_surface(_surface
);
1004 struct pipe_surface
*surface
= tr_surf
->surface
;
1006 trace_dump_call_begin("pipe_context", "surface_destroy");
1008 trace_dump_arg(ptr
, pipe
);
1009 trace_dump_arg(ptr
, surface
);
1011 trace_dump_call_end();
1013 trace_surf_destroy(tr_surf
);
1018 trace_context_set_sampler_views(struct pipe_context
*_pipe
,
1022 struct pipe_sampler_view
**views
)
1024 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1025 struct trace_sampler_view
*tr_view
;
1026 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1027 struct pipe_sampler_view
*unwrapped_views
[PIPE_MAX_SHADER_SAMPLER_VIEWS
];
1030 /* remove this when we have pipe->set_sampler_views(..., start, ...) */
1033 for (i
= 0; i
< num
; ++i
) {
1034 tr_view
= trace_sampler_view(views
[i
]);
1035 unwrapped_views
[i
] = tr_view
? tr_view
->sampler_view
: NULL
;
1037 views
= unwrapped_views
;
1039 trace_dump_call_begin("pipe_context", "set_sampler_views");
1041 trace_dump_arg(ptr
, pipe
);
1042 trace_dump_arg(uint
, shader
);
1043 trace_dump_arg(uint
, start
);
1044 trace_dump_arg(uint
, num
);
1045 trace_dump_arg_array(ptr
, views
, num
);
1047 pipe
->set_sampler_views(pipe
, shader
, start
, num
, views
);
1049 trace_dump_call_end();
1054 trace_context_set_vertex_buffers(struct pipe_context
*_pipe
,
1055 unsigned start_slot
, unsigned num_buffers
,
1056 const struct pipe_vertex_buffer
*buffers
)
1058 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1059 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1062 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1064 trace_dump_arg(ptr
, pipe
);
1065 trace_dump_arg(uint
, start_slot
);
1066 trace_dump_arg(uint
, num_buffers
);
1068 trace_dump_arg_begin("buffers");
1069 trace_dump_struct_array(vertex_buffer
, buffers
, num_buffers
);
1070 trace_dump_arg_end();
1073 struct pipe_vertex_buffer
*_buffers
= MALLOC(num_buffers
* sizeof(*_buffers
));
1074 memcpy(_buffers
, buffers
, num_buffers
* sizeof(*_buffers
));
1075 for (i
= 0; i
< num_buffers
; i
++)
1076 _buffers
[i
].buffer
= trace_resource_unwrap(tr_ctx
, buffers
[i
].buffer
);
1077 pipe
->set_vertex_buffers(pipe
, start_slot
, num_buffers
, _buffers
);
1080 pipe
->set_vertex_buffers(pipe
, start_slot
, num_buffers
, NULL
);
1083 trace_dump_call_end();
1088 trace_context_set_index_buffer(struct pipe_context
*_pipe
,
1089 const struct pipe_index_buffer
*ib
)
1091 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1092 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1094 trace_dump_call_begin("pipe_context", "set_index_buffer");
1096 trace_dump_arg(ptr
, pipe
);
1097 trace_dump_arg(index_buffer
, ib
);
1100 struct pipe_index_buffer _ib
;
1102 _ib
.buffer
= trace_resource_unwrap(tr_ctx
, ib
->buffer
);
1103 pipe
->set_index_buffer(pipe
, &_ib
);
1105 pipe
->set_index_buffer(pipe
, NULL
);
1108 trace_dump_call_end();
1112 static struct pipe_stream_output_target
*
1113 trace_context_create_stream_output_target(struct pipe_context
*_pipe
,
1114 struct pipe_resource
*res
,
1115 unsigned buffer_offset
,
1116 unsigned buffer_size
)
1118 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1119 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1120 struct pipe_stream_output_target
*result
;
1122 res
= trace_resource_unwrap(tr_ctx
, res
);
1124 trace_dump_call_begin("pipe_context", "create_stream_output_target");
1126 trace_dump_arg(ptr
, pipe
);
1127 trace_dump_arg(ptr
, res
);
1128 trace_dump_arg(uint
, buffer_offset
);
1129 trace_dump_arg(uint
, buffer_size
);
1131 result
= pipe
->create_stream_output_target(pipe
,
1132 res
, buffer_offset
, buffer_size
);
1134 trace_dump_ret(ptr
, result
);
1136 trace_dump_call_end();
1143 trace_context_stream_output_target_destroy(
1144 struct pipe_context
*_pipe
,
1145 struct pipe_stream_output_target
*target
)
1147 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1148 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1150 trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1152 trace_dump_arg(ptr
, pipe
);
1153 trace_dump_arg(ptr
, target
);
1155 pipe
->stream_output_target_destroy(pipe
, target
);
1157 trace_dump_call_end();
1162 trace_context_set_stream_output_targets(struct pipe_context
*_pipe
,
1163 unsigned num_targets
,
1164 struct pipe_stream_output_target
**tgs
,
1165 const unsigned *offsets
)
1167 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1168 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1170 trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1172 trace_dump_arg(ptr
, pipe
);
1173 trace_dump_arg(uint
, num_targets
);
1174 trace_dump_arg_array(ptr
, tgs
, num_targets
);
1175 trace_dump_arg_array(uint
, offsets
, num_targets
);
1177 pipe
->set_stream_output_targets(pipe
, num_targets
, tgs
, offsets
);
1179 trace_dump_call_end();
1184 trace_context_resource_copy_region(struct pipe_context
*_pipe
,
1185 struct pipe_resource
*dst
,
1187 unsigned dstx
, unsigned dsty
, unsigned dstz
,
1188 struct pipe_resource
*src
,
1190 const struct pipe_box
*src_box
)
1192 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1193 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1195 dst
= trace_resource_unwrap(tr_ctx
, dst
);
1196 src
= trace_resource_unwrap(tr_ctx
, src
);
1198 trace_dump_call_begin("pipe_context", "resource_copy_region");
1200 trace_dump_arg(ptr
, pipe
);
1201 trace_dump_arg(ptr
, dst
);
1202 trace_dump_arg(uint
, dst_level
);
1203 trace_dump_arg(uint
, dstx
);
1204 trace_dump_arg(uint
, dsty
);
1205 trace_dump_arg(uint
, dstz
);
1206 trace_dump_arg(ptr
, src
);
1207 trace_dump_arg(uint
, src_level
);
1208 trace_dump_arg(box
, src_box
);
1210 pipe
->resource_copy_region(pipe
,
1211 dst
, dst_level
, dstx
, dsty
, dstz
,
1212 src
, src_level
, src_box
);
1214 trace_dump_call_end();
1219 trace_context_blit(struct pipe_context
*_pipe
,
1220 const struct pipe_blit_info
*_info
)
1222 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1223 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1224 struct pipe_blit_info info
= *_info
;
1226 info
.dst
.resource
= trace_resource_unwrap(tr_ctx
, info
.dst
.resource
);
1227 info
.src
.resource
= trace_resource_unwrap(tr_ctx
, info
.src
.resource
);
1229 trace_dump_call_begin("pipe_context", "blit");
1231 trace_dump_arg(ptr
, pipe
);
1232 trace_dump_arg(blit_info
, _info
);
1234 pipe
->blit(pipe
, &info
);
1236 trace_dump_call_end();
1241 trace_context_flush_resource(struct pipe_context
*_pipe
,
1242 struct pipe_resource
*resource
)
1244 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1245 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1247 resource
= trace_resource_unwrap(tr_ctx
, resource
);
1249 trace_dump_call_begin("pipe_context", "flush_resource");
1251 trace_dump_arg(ptr
, pipe
);
1252 trace_dump_arg(ptr
, resource
);
1254 pipe
->flush_resource(pipe
, resource
);
1256 trace_dump_call_end();
1261 trace_context_clear(struct pipe_context
*_pipe
,
1263 const union pipe_color_union
*color
,
1267 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1268 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1270 trace_dump_call_begin("pipe_context", "clear");
1272 trace_dump_arg(ptr
, pipe
);
1273 trace_dump_arg(uint
, buffers
);
1274 trace_dump_arg_begin("color");
1276 trace_dump_array(float, color
->f
, 4);
1279 trace_dump_arg_end();
1280 trace_dump_arg(float, depth
);
1281 trace_dump_arg(uint
, stencil
);
1283 pipe
->clear(pipe
, buffers
, color
, depth
, stencil
);
1285 trace_dump_call_end();
1290 trace_context_clear_render_target(struct pipe_context
*_pipe
,
1291 struct pipe_surface
*dst
,
1292 const union pipe_color_union
*color
,
1293 unsigned dstx
, unsigned dsty
,
1294 unsigned width
, unsigned height
,
1295 bool render_condition_enabled
)
1297 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1298 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1300 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1302 trace_dump_call_begin("pipe_context", "clear_render_target");
1304 trace_dump_arg(ptr
, pipe
);
1305 trace_dump_arg(ptr
, dst
);
1306 trace_dump_arg_array(float, color
->f
, 4);
1307 trace_dump_arg(uint
, dstx
);
1308 trace_dump_arg(uint
, dsty
);
1309 trace_dump_arg(uint
, width
);
1310 trace_dump_arg(uint
, height
);
1311 trace_dump_arg(bool, render_condition_enabled
);
1313 pipe
->clear_render_target(pipe
, dst
, color
, dstx
, dsty
, width
, height
,
1314 render_condition_enabled
);
1316 trace_dump_call_end();
1320 trace_context_clear_depth_stencil(struct pipe_context
*_pipe
,
1321 struct pipe_surface
*dst
,
1322 unsigned clear_flags
,
1325 unsigned dstx
, unsigned dsty
,
1326 unsigned width
, unsigned height
,
1327 bool render_condition_enabled
)
1329 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1330 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1332 dst
= trace_surface_unwrap(tr_ctx
, dst
);
1334 trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1336 trace_dump_arg(ptr
, pipe
);
1337 trace_dump_arg(ptr
, dst
);
1338 trace_dump_arg(uint
, clear_flags
);
1339 trace_dump_arg(float, depth
);
1340 trace_dump_arg(uint
, stencil
);
1341 trace_dump_arg(uint
, dstx
);
1342 trace_dump_arg(uint
, dsty
);
1343 trace_dump_arg(uint
, width
);
1344 trace_dump_arg(uint
, height
);
1345 trace_dump_arg(bool, render_condition_enabled
);
1347 pipe
->clear_depth_stencil(pipe
, dst
, clear_flags
, depth
, stencil
,
1348 dstx
, dsty
, width
, height
,
1349 render_condition_enabled
);
1351 trace_dump_call_end();
1355 trace_context_clear_texture(struct pipe_context
*_pipe
,
1356 struct pipe_resource
*res
,
1358 const struct pipe_box
*box
,
1361 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1362 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1364 res
= trace_resource_unwrap(tr_ctx
, res
);
1366 trace_dump_call_begin("pipe_context", "clear_texture");
1368 trace_dump_arg(ptr
, pipe
);
1369 trace_dump_arg(ptr
, res
);
1370 trace_dump_arg(uint
, level
);
1371 trace_dump_arg_begin("box");
1372 trace_dump_box(box
);
1373 trace_dump_arg_end();
1374 trace_dump_arg(ptr
, data
);
1376 pipe
->clear_texture(pipe
, res
, level
, box
, data
);
1378 trace_dump_call_end();
1382 trace_context_flush(struct pipe_context
*_pipe
,
1383 struct pipe_fence_handle
**fence
,
1386 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1387 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1389 trace_dump_call_begin("pipe_context", "flush");
1391 trace_dump_arg(ptr
, pipe
);
1392 trace_dump_arg(uint
, flags
);
1394 pipe
->flush(pipe
, fence
, flags
);
1397 trace_dump_ret(ptr
, *fence
);
1399 trace_dump_call_end();
1403 static inline boolean
1404 trace_context_generate_mipmap(struct pipe_context
*_pipe
,
1405 struct pipe_resource
*res
,
1406 enum pipe_format format
,
1407 unsigned base_level
,
1408 unsigned last_level
,
1409 unsigned first_layer
,
1410 unsigned last_layer
)
1412 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1413 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1416 res
= trace_resource_unwrap(tr_ctx
, res
);
1418 trace_dump_call_begin("pipe_context", "generate_mipmap");
1420 trace_dump_arg(ptr
, pipe
);
1421 trace_dump_arg(ptr
, res
);
1423 trace_dump_arg(format
, format
);
1424 trace_dump_arg(uint
, base_level
);
1425 trace_dump_arg(uint
, last_level
);
1426 trace_dump_arg(uint
, first_layer
);
1427 trace_dump_arg(uint
, last_layer
);
1429 ret
= pipe
->generate_mipmap(pipe
, res
, format
, base_level
, last_level
,
1430 first_layer
, last_layer
);
1432 trace_dump_ret(bool, ret
);
1433 trace_dump_call_end();
1440 trace_context_destroy(struct pipe_context
*_pipe
)
1442 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1443 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1445 trace_dump_call_begin("pipe_context", "destroy");
1446 trace_dump_arg(ptr
, pipe
);
1447 trace_dump_call_end();
1449 pipe
->destroy(pipe
);
1455 /********************************************************************
1461 trace_context_transfer_map(struct pipe_context
*_context
,
1462 struct pipe_resource
*_resource
,
1465 const struct pipe_box
*box
,
1466 struct pipe_transfer
**transfer
)
1468 struct trace_context
*tr_context
= trace_context(_context
);
1469 struct trace_resource
*tr_res
= trace_resource(_resource
);
1470 struct pipe_context
*context
= tr_context
->pipe
;
1471 struct pipe_resource
*texture
= tr_res
->resource
;
1472 struct pipe_transfer
*result
= NULL
;
1475 assert(texture
->screen
== context
->screen
);
1478 * Map and transfers can't be serialized so we convert all write transfers
1479 * to texture/buffer_subdata and ignore read transfers.
1482 map
= context
->transfer_map(context
, texture
, level
, usage
, box
, &result
);
1486 *transfer
= trace_transfer_create(tr_context
, tr_res
, result
);
1489 if (usage
& PIPE_TRANSFER_WRITE
) {
1490 trace_transfer(*transfer
)->map
= map
;
1494 return *transfer
? map
: NULL
;
1498 trace_context_transfer_flush_region( struct pipe_context
*_context
,
1499 struct pipe_transfer
*_transfer
,
1500 const struct pipe_box
*box
)
1502 struct trace_context
*tr_context
= trace_context(_context
);
1503 struct trace_transfer
*tr_transfer
= trace_transfer(_transfer
);
1504 struct pipe_context
*context
= tr_context
->pipe
;
1505 struct pipe_transfer
*transfer
= tr_transfer
->transfer
;
1507 context
->transfer_flush_region(context
, transfer
, box
);
1511 trace_context_transfer_unmap(struct pipe_context
*_context
,
1512 struct pipe_transfer
*_transfer
)
1514 struct trace_context
*tr_ctx
= trace_context(_context
);
1515 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
1516 struct pipe_context
*context
= tr_ctx
->pipe
;
1517 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
1519 if (tr_trans
->map
) {
1521 * Fake a texture/buffer_subdata
1524 struct pipe_resource
*resource
= transfer
->resource
;
1525 unsigned level
= transfer
->level
;
1526 unsigned usage
= transfer
->usage
;
1527 const struct pipe_box
*box
= &transfer
->box
;
1528 unsigned stride
= transfer
->stride
;
1529 unsigned layer_stride
= transfer
->layer_stride
;
1531 if (resource
->target
== PIPE_BUFFER
)
1532 trace_dump_call_begin("pipe_context", "buffer_subdata");
1534 trace_dump_call_begin("pipe_context", "texture_subdata");
1536 trace_dump_arg(ptr
, context
);
1537 trace_dump_arg(ptr
, resource
);
1538 trace_dump_arg(uint
, level
);
1539 trace_dump_arg(uint
, usage
);
1540 trace_dump_arg(box
, box
);
1542 trace_dump_arg_begin("data");
1543 trace_dump_box_bytes(tr_trans
->map
,
1548 trace_dump_arg_end();
1550 trace_dump_arg(uint
, stride
);
1551 trace_dump_arg(uint
, layer_stride
);
1553 trace_dump_call_end();
1555 tr_trans
->map
= NULL
;
1558 context
->transfer_unmap(context
, transfer
);
1559 trace_transfer_destroy(tr_ctx
, tr_trans
);
1564 trace_context_buffer_subdata(struct pipe_context
*_context
,
1565 struct pipe_resource
*_resource
,
1566 unsigned usage
, unsigned offset
,
1567 unsigned size
, const void *data
)
1569 struct trace_context
*tr_context
= trace_context(_context
);
1570 struct trace_resource
*tr_res
= trace_resource(_resource
);
1571 struct pipe_context
*context
= tr_context
->pipe
;
1572 struct pipe_resource
*resource
= tr_res
->resource
;
1573 struct pipe_box box
;
1575 assert(resource
->screen
== context
->screen
);
1577 trace_dump_call_begin("pipe_context", "buffer_subdata");
1579 trace_dump_arg(ptr
, context
);
1580 trace_dump_arg(ptr
, resource
);
1581 trace_dump_arg(uint
, usage
);
1582 trace_dump_arg(uint
, offset
);
1583 trace_dump_arg(uint
, size
);
1585 trace_dump_arg_begin("data");
1586 u_box_1d(offset
, size
, &box
);
1587 trace_dump_box_bytes(data
, resource
, &box
, 0, 0);
1588 trace_dump_arg_end();
1590 trace_dump_call_end();
1592 context
->buffer_subdata(context
, resource
, usage
, offset
, size
, data
);
1597 trace_context_texture_subdata(struct pipe_context
*_context
,
1598 struct pipe_resource
*_resource
,
1601 const struct pipe_box
*box
,
1604 unsigned layer_stride
)
1606 struct trace_context
*tr_context
= trace_context(_context
);
1607 struct trace_resource
*tr_res
= trace_resource(_resource
);
1608 struct pipe_context
*context
= tr_context
->pipe
;
1609 struct pipe_resource
*resource
= tr_res
->resource
;
1611 assert(resource
->screen
== context
->screen
);
1613 trace_dump_call_begin("pipe_context", "texture_subdata");
1615 trace_dump_arg(ptr
, context
);
1616 trace_dump_arg(ptr
, resource
);
1617 trace_dump_arg(uint
, level
);
1618 trace_dump_arg(uint
, usage
);
1619 trace_dump_arg(box
, box
);
1621 trace_dump_arg_begin("data");
1622 trace_dump_box_bytes(data
,
1627 trace_dump_arg_end();
1629 trace_dump_arg(uint
, stride
);
1630 trace_dump_arg(uint
, layer_stride
);
1632 trace_dump_call_end();
1634 context
->texture_subdata(context
, resource
, level
, usage
, box
,
1635 data
, stride
, layer_stride
);
1640 trace_context_render_condition(struct pipe_context
*_context
,
1641 struct pipe_query
*query
,
1645 struct trace_context
*tr_context
= trace_context(_context
);
1646 struct pipe_context
*context
= tr_context
->pipe
;
1648 query
= trace_query_unwrap(query
);
1650 trace_dump_call_begin("pipe_context", "render_condition");
1652 trace_dump_arg(ptr
, context
);
1653 trace_dump_arg(ptr
, query
);
1654 trace_dump_arg(bool, condition
);
1655 trace_dump_arg(uint
, mode
);
1657 trace_dump_call_end();
1659 context
->render_condition(context
, query
, condition
, mode
);
1664 trace_context_texture_barrier(struct pipe_context
*_context
)
1666 struct trace_context
*tr_context
= trace_context(_context
);
1667 struct pipe_context
*context
= tr_context
->pipe
;
1669 trace_dump_call_begin("pipe_context", "texture_barrier");
1671 trace_dump_arg(ptr
, context
);
1673 trace_dump_call_end();
1675 context
->texture_barrier(context
);
1680 trace_context_memory_barrier(struct pipe_context
*_context
,
1683 struct trace_context
*tr_context
= trace_context(_context
);
1684 struct pipe_context
*context
= tr_context
->pipe
;
1686 trace_dump_call_begin("pipe_context", "memory_barrier");
1687 trace_dump_arg(ptr
, context
);
1688 trace_dump_arg(uint
, flags
);
1689 trace_dump_call_end();
1691 context
->memory_barrier(context
, flags
);
1696 trace_context_set_tess_state(struct pipe_context
*_context
,
1697 const float default_outer_level
[4],
1698 const float default_inner_level
[2])
1700 struct trace_context
*tr_context
= trace_context(_context
);
1701 struct pipe_context
*context
= tr_context
->pipe
;
1703 trace_dump_call_begin("pipe_context", "set_tess_state");
1704 trace_dump_arg(ptr
, context
);
1705 trace_dump_arg_array(float, default_outer_level
, 4);
1706 trace_dump_arg_array(float, default_inner_level
, 2);
1707 trace_dump_call_end();
1709 context
->set_tess_state(context
, default_outer_level
, default_inner_level
);
1713 static void trace_context_set_shader_buffers(struct pipe_context
*_context
,
1715 unsigned start
, unsigned nr
,
1716 const struct pipe_shader_buffer
*buffers
)
1718 struct trace_context
*tr_context
= trace_context(_context
);
1719 struct pipe_context
*context
= tr_context
->pipe
;
1720 struct pipe_shader_buffer
*_buffers
= NULL
;
1722 trace_dump_call_begin("pipe_context", "set_shader_buffers");
1723 trace_dump_arg(ptr
, context
);
1724 trace_dump_arg(uint
, shader
);
1725 trace_dump_arg(uint
, start
);
1726 trace_dump_arg_begin("buffers");
1727 trace_dump_struct_array(shader_buffer
, buffers
, nr
);
1728 trace_dump_arg_end();
1729 trace_dump_call_end();
1734 _buffers
= MALLOC(nr
* sizeof(struct pipe_shader_buffer
));
1738 for (i
= 0; i
< nr
; i
++) {
1739 _buffers
[i
] = buffers
[i
];
1740 _buffers
[i
].buffer
= trace_resource_unwrap(
1741 tr_context
, _buffers
[i
].buffer
);
1745 context
->set_shader_buffers(context
, shader
, start
, nr
, _buffers
);
1751 static void trace_context_set_shader_images(struct pipe_context
*_context
,
1753 unsigned start
, unsigned nr
,
1754 const struct pipe_image_view
*images
)
1756 struct trace_context
*tr_context
= trace_context(_context
);
1757 struct pipe_context
*context
= tr_context
->pipe
;
1758 struct pipe_image_view
*_images
= NULL
;
1760 trace_dump_call_begin("pipe_context", "set_shader_images");
1761 trace_dump_arg(ptr
, context
);
1762 trace_dump_arg(uint
, shader
);
1763 trace_dump_arg(uint
, start
);
1764 trace_dump_arg_begin("images");
1765 trace_dump_struct_array(image_view
, images
, nr
);
1766 trace_dump_arg_end();
1767 trace_dump_call_end();
1772 _images
= MALLOC(nr
* sizeof(struct pipe_image_view
));
1776 for (i
= 0; i
< nr
; i
++) {
1777 _images
[i
] = images
[i
];
1778 _images
[i
].resource
= trace_resource_unwrap(tr_context
,
1779 _images
[i
].resource
);
1783 context
->set_shader_images(context
, shader
, start
, nr
, _images
);
1789 static void trace_context_launch_grid(struct pipe_context
*_pipe
,
1790 const struct pipe_grid_info
*info
)
1792 struct trace_context
*tr_ctx
= trace_context(_pipe
);
1793 struct pipe_context
*pipe
= tr_ctx
->pipe
;
1795 trace_dump_call_begin("pipe_context", "launch_grid");
1797 trace_dump_arg(ptr
, pipe
);
1798 trace_dump_arg(grid_info
, info
);
1800 trace_dump_trace_flush();
1802 if (info
->indirect
) {
1803 struct pipe_grid_info _info
;
1805 memcpy(&_info
, info
, sizeof(_info
));
1806 _info
.indirect
= trace_resource_unwrap(tr_ctx
, _info
.indirect
);
1807 pipe
->launch_grid(pipe
, &_info
);
1809 pipe
->launch_grid(pipe
, info
);
1812 trace_dump_call_end();
1815 struct pipe_context
*
1816 trace_context_create(struct trace_screen
*tr_scr
,
1817 struct pipe_context
*pipe
)
1819 struct trace_context
*tr_ctx
;
1824 if (!trace_enabled())
1827 tr_ctx
= CALLOC_STRUCT(trace_context
);
1831 tr_ctx
->base
.priv
= pipe
->priv
; /* expose wrapped priv data */
1832 tr_ctx
->base
.screen
= &tr_scr
->base
;
1834 tr_ctx
->base
.destroy
= trace_context_destroy
;
1836 #define TR_CTX_INIT(_member) \
1837 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1839 TR_CTX_INIT(draw_vbo
);
1840 TR_CTX_INIT(render_condition
);
1841 TR_CTX_INIT(create_query
);
1842 TR_CTX_INIT(destroy_query
);
1843 TR_CTX_INIT(begin_query
);
1844 TR_CTX_INIT(end_query
);
1845 TR_CTX_INIT(get_query_result
);
1846 TR_CTX_INIT(set_active_query_state
);
1847 TR_CTX_INIT(create_blend_state
);
1848 TR_CTX_INIT(bind_blend_state
);
1849 TR_CTX_INIT(delete_blend_state
);
1850 TR_CTX_INIT(create_sampler_state
);
1851 TR_CTX_INIT(bind_sampler_states
);
1852 TR_CTX_INIT(delete_sampler_state
);
1853 TR_CTX_INIT(create_rasterizer_state
);
1854 TR_CTX_INIT(bind_rasterizer_state
);
1855 TR_CTX_INIT(delete_rasterizer_state
);
1856 TR_CTX_INIT(create_depth_stencil_alpha_state
);
1857 TR_CTX_INIT(bind_depth_stencil_alpha_state
);
1858 TR_CTX_INIT(delete_depth_stencil_alpha_state
);
1859 TR_CTX_INIT(create_fs_state
);
1860 TR_CTX_INIT(bind_fs_state
);
1861 TR_CTX_INIT(delete_fs_state
);
1862 TR_CTX_INIT(create_vs_state
);
1863 TR_CTX_INIT(bind_vs_state
);
1864 TR_CTX_INIT(delete_vs_state
);
1865 TR_CTX_INIT(create_gs_state
);
1866 TR_CTX_INIT(bind_gs_state
);
1867 TR_CTX_INIT(delete_gs_state
);
1868 TR_CTX_INIT(create_tcs_state
);
1869 TR_CTX_INIT(bind_tcs_state
);
1870 TR_CTX_INIT(delete_tcs_state
);
1871 TR_CTX_INIT(create_tes_state
);
1872 TR_CTX_INIT(bind_tes_state
);
1873 TR_CTX_INIT(delete_tes_state
);
1874 TR_CTX_INIT(create_compute_state
);
1875 TR_CTX_INIT(bind_compute_state
);
1876 TR_CTX_INIT(delete_compute_state
);
1877 TR_CTX_INIT(create_vertex_elements_state
);
1878 TR_CTX_INIT(bind_vertex_elements_state
);
1879 TR_CTX_INIT(delete_vertex_elements_state
);
1880 TR_CTX_INIT(set_blend_color
);
1881 TR_CTX_INIT(set_stencil_ref
);
1882 TR_CTX_INIT(set_clip_state
);
1883 TR_CTX_INIT(set_sample_mask
);
1884 TR_CTX_INIT(set_constant_buffer
);
1885 TR_CTX_INIT(set_framebuffer_state
);
1886 TR_CTX_INIT(set_polygon_stipple
);
1887 TR_CTX_INIT(set_scissor_states
);
1888 TR_CTX_INIT(set_viewport_states
);
1889 TR_CTX_INIT(set_sampler_views
);
1890 TR_CTX_INIT(create_sampler_view
);
1891 TR_CTX_INIT(sampler_view_destroy
);
1892 TR_CTX_INIT(create_surface
);
1893 TR_CTX_INIT(surface_destroy
);
1894 TR_CTX_INIT(set_vertex_buffers
);
1895 TR_CTX_INIT(set_index_buffer
);
1896 TR_CTX_INIT(create_stream_output_target
);
1897 TR_CTX_INIT(stream_output_target_destroy
);
1898 TR_CTX_INIT(set_stream_output_targets
);
1899 TR_CTX_INIT(resource_copy_region
);
1901 TR_CTX_INIT(flush_resource
);
1903 TR_CTX_INIT(clear_render_target
);
1904 TR_CTX_INIT(clear_depth_stencil
);
1905 TR_CTX_INIT(clear_texture
);
1907 TR_CTX_INIT(generate_mipmap
);
1908 TR_CTX_INIT(texture_barrier
);
1909 TR_CTX_INIT(memory_barrier
);
1910 TR_CTX_INIT(set_tess_state
);
1911 TR_CTX_INIT(set_shader_buffers
);
1912 TR_CTX_INIT(launch_grid
);
1913 TR_CTX_INIT(set_shader_images
);
1915 TR_CTX_INIT(transfer_map
);
1916 TR_CTX_INIT(transfer_unmap
);
1917 TR_CTX_INIT(transfer_flush_region
);
1918 TR_CTX_INIT(buffer_subdata
);
1919 TR_CTX_INIT(texture_subdata
);
1923 tr_ctx
->pipe
= pipe
;
1925 return &tr_ctx
->base
;
1933 * Sanity checker: check that the given context really is a
1934 * trace context (and not the wrapped driver's context).
1937 trace_context_check(const struct pipe_context
*pipe
)
1939 MAYBE_UNUSED
struct trace_context
*tr_ctx
= (struct trace_context
*) pipe
;
1940 assert(tr_ctx
->base
.destroy
== trace_context_destroy
);