1 /**************************************************************************
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "util/u_memory.h"
29 #include "util/u_simple_list.h"
31 #include "pipe/p_screen.h"
34 #include "tr_dump_state.h"
36 #include "tr_buffer.h"
37 #include "tr_screen.h"
38 #include "tr_texture.h"
41 static INLINE struct pipe_buffer *
42 trace_buffer_unwrap(struct trace_context *tr_ctx,
43 struct pipe_buffer *buffer)
45 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
46 struct trace_buffer *tr_buf;
51 tr_buf = trace_buffer(buffer);
53 assert(tr_buf->buffer);
54 assert(tr_buf->buffer->screen == tr_scr->screen);
56 return tr_buf->buffer;
60 static INLINE struct pipe_texture *
61 trace_texture_unwrap(struct trace_context *tr_ctx,
62 struct pipe_texture *texture)
64 struct trace_texture *tr_tex;
69 tr_tex = trace_texture(texture);
71 assert(tr_tex->texture);
72 return tr_tex->texture;
76 static INLINE struct pipe_surface *
77 trace_surface_unwrap(struct trace_context *tr_ctx,
78 struct pipe_surface *surface)
80 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
81 struct trace_surface *tr_surf;
86 assert(surface->texture);
90 tr_surf = trace_surface(surface);
92 assert(tr_surf->surface);
93 assert(tr_surf->surface->texture->screen == tr_scr->screen);
95 return tr_surf->surface;
100 trace_context_draw_block(struct trace_context *tr_ctx, int flag)
104 pipe_mutex_lock(tr_ctx->draw_mutex);
106 if (tr_ctx->draw_blocker & flag) {
107 tr_ctx->draw_blocked |= flag;
108 } else if ((tr_ctx->draw_rule.blocker & flag) &&
109 (tr_ctx->draw_blocker & 4)) {
110 boolean block = FALSE;
111 debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
112 (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
113 (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
114 (void *) tr_ctx->draw_rule.surf, 0,
115 (void *) tr_ctx->draw_rule.tex, 0);
116 if (tr_ctx->draw_rule.fs &&
117 tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
119 if (tr_ctx->draw_rule.vs &&
120 tr_ctx->draw_rule.vs == tr_ctx->curr.vs)
122 if (tr_ctx->draw_rule.surf &&
123 tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf)
125 if (tr_ctx->draw_rule.surf)
126 for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
127 if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
129 if (tr_ctx->draw_rule.tex) {
130 for (k = 0; k < tr_ctx->curr.num_texs; k++)
131 if (tr_ctx->draw_rule.tex == tr_ctx->curr.tex[k])
133 for (k = 0; k < tr_ctx->curr.num_vert_texs; k++) {
134 if (tr_ctx->draw_rule.tex == tr_ctx->curr.vert_tex[k]) {
141 tr_ctx->draw_blocked |= (flag | 4);
144 if (tr_ctx->draw_blocked)
145 trace_rbug_notify_draw_blocked(tr_ctx);
147 /* wait for rbug to clear the blocked flag */
148 while (tr_ctx->draw_blocked & flag) {
149 tr_ctx->draw_blocked |= flag;
150 #ifdef PIPE_THREAD_HAVE_CONDVAR
151 pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex);
153 pipe_mutex_unlock(tr_ctx->draw_mutex);
154 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
157 pipe_mutex_lock(tr_ctx->draw_mutex);
161 pipe_mutex_unlock(tr_ctx->draw_mutex);
164 static INLINE boolean
165 trace_context_draw_arrays(struct pipe_context *_pipe,
166 unsigned mode, unsigned start, unsigned count)
168 struct trace_context *tr_ctx = trace_context(_pipe);
169 struct pipe_context *pipe = tr_ctx->pipe;
172 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
175 trace_context_draw_block(tr_ctx, 1);
177 trace_dump_call_begin("pipe_context", "draw_arrays");
179 trace_dump_arg(ptr, pipe);
180 trace_dump_arg(uint, mode);
181 trace_dump_arg(uint, start);
182 trace_dump_arg(uint, count);
184 result = pipe->draw_arrays(pipe, mode, start, count);
186 trace_dump_ret(bool, result);
188 trace_dump_call_end();
190 trace_context_draw_block(tr_ctx, 2);
196 static INLINE boolean
197 trace_context_draw_elements(struct pipe_context *_pipe,
198 struct pipe_buffer *_indexBuffer,
200 unsigned mode, unsigned start, unsigned count)
202 struct trace_context *tr_ctx = trace_context(_pipe);
203 struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
204 struct pipe_context *pipe = tr_ctx->pipe;
205 struct pipe_buffer *indexBuffer = tr_buf->buffer;
208 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
211 trace_context_draw_block(tr_ctx, 1);
213 trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
215 trace_dump_call_begin("pipe_context", "draw_elements");
217 trace_dump_arg(ptr, pipe);
218 trace_dump_arg(ptr, indexBuffer);
219 trace_dump_arg(uint, indexSize);
220 trace_dump_arg(uint, mode);
221 trace_dump_arg(uint, start);
222 trace_dump_arg(uint, count);
224 result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);
226 trace_dump_ret(bool, result);
228 trace_dump_call_end();
230 trace_context_draw_block(tr_ctx, 2);
236 static INLINE boolean
237 trace_context_draw_range_elements(struct pipe_context *_pipe,
238 struct pipe_buffer *_indexBuffer,
246 struct trace_context *tr_ctx = trace_context(_pipe);
247 struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
248 struct pipe_context *pipe = tr_ctx->pipe;
249 struct pipe_buffer *indexBuffer = tr_buf->buffer;
252 if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
255 trace_context_draw_block(tr_ctx, 1);
257 trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
259 trace_dump_call_begin("pipe_context", "draw_range_elements");
261 trace_dump_arg(ptr, pipe);
262 trace_dump_arg(ptr, indexBuffer);
263 trace_dump_arg(uint, indexSize);
264 trace_dump_arg(uint, minIndex);
265 trace_dump_arg(uint, maxIndex);
266 trace_dump_arg(uint, mode);
267 trace_dump_arg(uint, start);
268 trace_dump_arg(uint, count);
270 result = pipe->draw_range_elements(pipe,
272 indexSize, minIndex, maxIndex,
275 trace_dump_ret(bool, result);
277 trace_dump_call_end();
279 trace_context_draw_block(tr_ctx, 2);
285 static INLINE struct pipe_query *
286 trace_context_create_query(struct pipe_context *_pipe,
289 struct trace_context *tr_ctx = trace_context(_pipe);
290 struct pipe_context *pipe = tr_ctx->pipe;
291 struct pipe_query *result;
293 trace_dump_call_begin("pipe_context", "create_query");
295 trace_dump_arg(ptr, pipe);
296 trace_dump_arg(uint, query_type);
298 result = pipe->create_query(pipe, query_type);
300 trace_dump_ret(ptr, result);
302 trace_dump_call_end();
309 trace_context_destroy_query(struct pipe_context *_pipe,
310 struct pipe_query *query)
312 struct trace_context *tr_ctx = trace_context(_pipe);
313 struct pipe_context *pipe = tr_ctx->pipe;
315 trace_dump_call_begin("pipe_context", "destroy_query");
317 trace_dump_arg(ptr, pipe);
318 trace_dump_arg(ptr, query);
320 pipe->destroy_query(pipe, query);
322 trace_dump_call_end();
327 trace_context_begin_query(struct pipe_context *_pipe,
328 struct pipe_query *query)
330 struct trace_context *tr_ctx = trace_context(_pipe);
331 struct pipe_context *pipe = tr_ctx->pipe;
333 trace_dump_call_begin("pipe_context", "begin_query");
335 trace_dump_arg(ptr, pipe);
336 trace_dump_arg(ptr, query);
338 pipe->begin_query(pipe, query);
340 trace_dump_call_end();
345 trace_context_end_query(struct pipe_context *_pipe,
346 struct pipe_query *query)
348 struct trace_context *tr_ctx = trace_context(_pipe);
349 struct pipe_context *pipe = tr_ctx->pipe;
351 trace_dump_call_begin("pipe_context", "end_query");
353 trace_dump_arg(ptr, pipe);
354 trace_dump_arg(ptr, query);
356 pipe->end_query(pipe, query);
358 trace_dump_call_end();
362 static INLINE boolean
363 trace_context_get_query_result(struct pipe_context *_pipe,
364 struct pipe_query *query,
368 struct trace_context *tr_ctx = trace_context(_pipe);
369 struct pipe_context *pipe = tr_ctx->pipe;
373 trace_dump_call_begin("pipe_context", "get_query_result");
375 trace_dump_arg(ptr, pipe);
377 _result = pipe->get_query_result(pipe, query, wait, presult);
380 trace_dump_arg(uint, result);
381 trace_dump_ret(bool, _result);
383 trace_dump_call_end();
390 trace_context_create_blend_state(struct pipe_context *_pipe,
391 const struct pipe_blend_state *state)
393 struct trace_context *tr_ctx = trace_context(_pipe);
394 struct pipe_context *pipe = tr_ctx->pipe;
397 trace_dump_call_begin("pipe_context", "create_blend_state");
399 trace_dump_arg(ptr, pipe);
400 trace_dump_arg(blend_state, state);
402 result = pipe->create_blend_state(pipe, state);
404 trace_dump_ret(ptr, result);
406 trace_dump_call_end();
413 trace_context_bind_blend_state(struct pipe_context *_pipe,
416 struct trace_context *tr_ctx = trace_context(_pipe);
417 struct pipe_context *pipe = tr_ctx->pipe;
419 trace_dump_call_begin("pipe_context", "bind_blend_state");
421 trace_dump_arg(ptr, pipe);
422 trace_dump_arg(ptr, state);
424 pipe->bind_blend_state(pipe, state);
426 trace_dump_call_end();
431 trace_context_delete_blend_state(struct pipe_context *_pipe,
434 struct trace_context *tr_ctx = trace_context(_pipe);
435 struct pipe_context *pipe = tr_ctx->pipe;
437 trace_dump_call_begin("pipe_context", "delete_blend_state");
439 trace_dump_arg(ptr, pipe);
440 trace_dump_arg(ptr, state);
442 pipe->delete_blend_state(pipe, state);
444 trace_dump_call_end();
449 trace_context_create_sampler_state(struct pipe_context *_pipe,
450 const struct pipe_sampler_state *state)
452 struct trace_context *tr_ctx = trace_context(_pipe);
453 struct pipe_context *pipe = tr_ctx->pipe;
456 trace_dump_call_begin("pipe_context", "create_sampler_state");
458 trace_dump_arg(ptr, pipe);
459 trace_dump_arg(sampler_state, state);
461 result = pipe->create_sampler_state(pipe, state);
463 trace_dump_ret(ptr, result);
465 trace_dump_call_end();
472 trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
476 struct trace_context *tr_ctx = trace_context(_pipe);
477 struct pipe_context *pipe = tr_ctx->pipe;
479 trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
481 trace_dump_arg(ptr, pipe);
482 trace_dump_arg(uint, num_states);
483 trace_dump_arg_array(ptr, states, num_states);
485 pipe->bind_fragment_sampler_states(pipe, num_states, states);
487 trace_dump_call_end();
492 trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
496 struct trace_context *tr_ctx = trace_context(_pipe);
497 struct pipe_context *pipe = tr_ctx->pipe;
499 trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
501 trace_dump_arg(ptr, pipe);
502 trace_dump_arg(uint, num_states);
503 trace_dump_arg_array(ptr, states, num_states);
505 pipe->bind_vertex_sampler_states(pipe, num_states, states);
507 trace_dump_call_end();
512 trace_context_delete_sampler_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", "delete_sampler_state");
520 trace_dump_arg(ptr, pipe);
521 trace_dump_arg(ptr, state);
523 pipe->delete_sampler_state(pipe, state);
525 trace_dump_call_end();
530 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
531 const struct pipe_rasterizer_state *state)
533 struct trace_context *tr_ctx = trace_context(_pipe);
534 struct pipe_context *pipe = tr_ctx->pipe;
537 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
539 trace_dump_arg(ptr, pipe);
540 trace_dump_arg(rasterizer_state, state);
542 result = pipe->create_rasterizer_state(pipe, state);
544 trace_dump_ret(ptr, result);
546 trace_dump_call_end();
553 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
556 struct trace_context *tr_ctx = trace_context(_pipe);
557 struct pipe_context *pipe = tr_ctx->pipe;
559 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
561 trace_dump_arg(ptr, pipe);
562 trace_dump_arg(ptr, state);
564 pipe->bind_rasterizer_state(pipe, state);
566 trace_dump_call_end();
571 trace_context_delete_rasterizer_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", "delete_rasterizer_state");
579 trace_dump_arg(ptr, pipe);
580 trace_dump_arg(ptr, state);
582 pipe->delete_rasterizer_state(pipe, state);
584 trace_dump_call_end();
589 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
590 const struct pipe_depth_stencil_alpha_state *state)
592 struct trace_context *tr_ctx = trace_context(_pipe);
593 struct pipe_context *pipe = tr_ctx->pipe;
596 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
598 result = pipe->create_depth_stencil_alpha_state(pipe, state);
600 trace_dump_arg(ptr, pipe);
601 trace_dump_arg(depth_stencil_alpha_state, state);
603 trace_dump_ret(ptr, result);
605 trace_dump_call_end();
612 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
615 struct trace_context *tr_ctx = trace_context(_pipe);
616 struct pipe_context *pipe = tr_ctx->pipe;
618 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
620 trace_dump_arg(ptr, pipe);
621 trace_dump_arg(ptr, state);
623 pipe->bind_depth_stencil_alpha_state(pipe, state);
625 trace_dump_call_end();
630 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
633 struct trace_context *tr_ctx = trace_context(_pipe);
634 struct pipe_context *pipe = tr_ctx->pipe;
636 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
638 trace_dump_arg(ptr, pipe);
639 trace_dump_arg(ptr, state);
641 pipe->delete_depth_stencil_alpha_state(pipe, state);
643 trace_dump_call_end();
648 trace_context_create_fs_state(struct pipe_context *_pipe,
649 const struct pipe_shader_state *state)
651 struct trace_context *tr_ctx = trace_context(_pipe);
652 struct pipe_context *pipe = tr_ctx->pipe;
655 trace_dump_call_begin("pipe_context", "create_fs_state");
657 trace_dump_arg(ptr, pipe);
658 trace_dump_arg(shader_state, state);
660 result = pipe->create_fs_state(pipe, state);
662 trace_dump_ret(ptr, result);
664 trace_dump_call_end();
666 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT);
673 trace_context_bind_fs_state(struct pipe_context *_pipe,
676 struct trace_context *tr_ctx = trace_context(_pipe);
677 struct trace_shader *tr_shdr = trace_shader(_state);
678 struct pipe_context *pipe = tr_ctx->pipe;
679 void *state = tr_shdr ? tr_shdr->state : NULL;
681 trace_dump_call_begin("pipe_context", "bind_fs_state");
683 trace_dump_arg(ptr, pipe);
684 trace_dump_arg(ptr, state);
686 tr_ctx->curr.fs = tr_shdr;
688 if (tr_shdr && tr_shdr->replaced)
689 state = tr_shdr->replaced;
691 pipe->bind_fs_state(pipe, state);
693 trace_dump_call_end();
698 trace_context_delete_fs_state(struct pipe_context *_pipe,
701 struct trace_context *tr_ctx = trace_context(_pipe);
702 struct trace_shader *tr_shdr = trace_shader(_state);
703 struct pipe_context *pipe = tr_ctx->pipe;
704 void *state = tr_shdr->state;
706 trace_dump_call_begin("pipe_context", "delete_fs_state");
708 trace_dump_arg(ptr, pipe);
709 trace_dump_arg(ptr, state);
711 pipe->delete_fs_state(pipe, state);
713 trace_dump_call_end();
715 trace_shader_destroy(tr_ctx, tr_shdr);
720 trace_context_create_vs_state(struct pipe_context *_pipe,
721 const struct pipe_shader_state *state)
723 struct trace_context *tr_ctx = trace_context(_pipe);
724 struct pipe_context *pipe = tr_ctx->pipe;
727 trace_dump_call_begin("pipe_context", "create_vs_state");
729 trace_dump_arg(ptr, pipe);
730 trace_dump_arg(shader_state, state);
732 result = pipe->create_vs_state(pipe, state);
734 trace_dump_ret(ptr, result);
736 trace_dump_call_end();
738 result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX);
745 trace_context_bind_vs_state(struct pipe_context *_pipe,
748 struct trace_context *tr_ctx = trace_context(_pipe);
749 struct trace_shader *tr_shdr = trace_shader(_state);
750 struct pipe_context *pipe = tr_ctx->pipe;
751 void *state = tr_shdr ? tr_shdr->state : NULL;
753 trace_dump_call_begin("pipe_context", "bind_vs_state");
755 trace_dump_arg(ptr, pipe);
756 trace_dump_arg(ptr, state);
758 tr_ctx->curr.vs = tr_shdr;
760 if (tr_shdr && tr_shdr->replaced)
761 state = tr_shdr->replaced;
763 pipe->bind_vs_state(pipe, state);
765 trace_dump_call_end();
770 trace_context_delete_vs_state(struct pipe_context *_pipe,
773 struct trace_context *tr_ctx = trace_context(_pipe);
774 struct trace_shader *tr_shdr = trace_shader(_state);
775 struct pipe_context *pipe = tr_ctx->pipe;
776 void *state = tr_shdr->state;
778 trace_dump_call_begin("pipe_context", "delete_vs_state");
780 trace_dump_arg(ptr, pipe);
781 trace_dump_arg(ptr, state);
783 pipe->delete_vs_state(pipe, state);
785 trace_dump_call_end();
787 trace_shader_destroy(tr_ctx, tr_shdr);
792 trace_context_set_blend_color(struct pipe_context *_pipe,
793 const struct pipe_blend_color *state)
795 struct trace_context *tr_ctx = trace_context(_pipe);
796 struct pipe_context *pipe = tr_ctx->pipe;
798 trace_dump_call_begin("pipe_context", "set_blend_color");
800 trace_dump_arg(ptr, pipe);
801 trace_dump_arg(blend_color, state);
803 pipe->set_blend_color(pipe, state);
805 trace_dump_call_end();
810 trace_context_set_clip_state(struct pipe_context *_pipe,
811 const struct pipe_clip_state *state)
813 struct trace_context *tr_ctx = trace_context(_pipe);
814 struct pipe_context *pipe = tr_ctx->pipe;
816 trace_dump_call_begin("pipe_context", "set_clip_state");
818 trace_dump_arg(ptr, pipe);
819 trace_dump_arg(clip_state, state);
821 pipe->set_clip_state(pipe, state);
823 trace_dump_call_end();
828 trace_context_set_constant_buffer(struct pipe_context *_pipe,
829 uint shader, uint index,
830 const struct pipe_constant_buffer *buffer)
832 struct trace_context *tr_ctx = trace_context(_pipe);
833 struct pipe_context *pipe = tr_ctx->pipe;
836 trace_screen_user_buffer_update(_pipe->screen, buffer->buffer);
838 trace_dump_call_begin("pipe_context", "set_constant_buffer");
840 trace_dump_arg(ptr, pipe);
841 trace_dump_arg(uint, shader);
842 trace_dump_arg(uint, index);
843 trace_dump_arg(constant_buffer, buffer);
846 struct pipe_constant_buffer _buffer;
847 _buffer.buffer = trace_buffer_unwrap(tr_ctx, buffer->buffer);
848 pipe->set_constant_buffer(pipe, shader, index, &_buffer);
850 pipe->set_constant_buffer(pipe, shader, index, buffer);
853 trace_dump_call_end();
858 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
859 const struct pipe_framebuffer_state *state)
861 struct trace_context *tr_ctx = trace_context(_pipe);
862 struct pipe_context *pipe = tr_ctx->pipe;
863 struct pipe_framebuffer_state unwrapped_state;
867 tr_ctx->curr.nr_cbufs = state->nr_cbufs;
868 for (i = 0; i < state->nr_cbufs; i++)
870 tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture);
872 tr_ctx->curr.cbufs[i] = NULL;
874 tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture);
876 tr_ctx->curr.zsbuf = NULL;
879 /* Unwrap the input state */
880 memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
881 for(i = 0; i < state->nr_cbufs; ++i)
882 unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
883 for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
884 unwrapped_state.cbufs[i] = NULL;
885 unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
886 state = &unwrapped_state;
888 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
890 trace_dump_arg(ptr, pipe);
891 trace_dump_arg(framebuffer_state, state);
893 pipe->set_framebuffer_state(pipe, state);
895 trace_dump_call_end();
900 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
901 const struct pipe_poly_stipple *state)
903 struct trace_context *tr_ctx = trace_context(_pipe);
904 struct pipe_context *pipe = tr_ctx->pipe;
906 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
908 trace_dump_arg(ptr, pipe);
909 trace_dump_arg(poly_stipple, state);
911 pipe->set_polygon_stipple(pipe, state);
913 trace_dump_call_end();
918 trace_context_set_scissor_state(struct pipe_context *_pipe,
919 const struct pipe_scissor_state *state)
921 struct trace_context *tr_ctx = trace_context(_pipe);
922 struct pipe_context *pipe = tr_ctx->pipe;
924 trace_dump_call_begin("pipe_context", "set_scissor_state");
926 trace_dump_arg(ptr, pipe);
927 trace_dump_arg(scissor_state, state);
929 pipe->set_scissor_state(pipe, state);
931 trace_dump_call_end();
936 trace_context_set_viewport_state(struct pipe_context *_pipe,
937 const struct pipe_viewport_state *state)
939 struct trace_context *tr_ctx = trace_context(_pipe);
940 struct pipe_context *pipe = tr_ctx->pipe;
942 trace_dump_call_begin("pipe_context", "set_viewport_state");
944 trace_dump_arg(ptr, pipe);
945 trace_dump_arg(viewport_state, state);
947 pipe->set_viewport_state(pipe, state);
949 trace_dump_call_end();
954 trace_context_set_fragment_sampler_textures(struct pipe_context *_pipe,
955 unsigned num_textures,
956 struct pipe_texture **textures)
958 struct trace_context *tr_ctx = trace_context(_pipe);
959 struct trace_texture *tr_tex;
960 struct pipe_context *pipe = tr_ctx->pipe;
961 struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
964 tr_ctx->curr.num_texs = num_textures;
965 for(i = 0; i < num_textures; ++i) {
966 tr_tex = trace_texture(textures[i]);
967 tr_ctx->curr.tex[i] = tr_tex;
968 unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
970 textures = unwrapped_textures;
972 trace_dump_call_begin("pipe_context", "set_fragment_sampler_textures");
974 trace_dump_arg(ptr, pipe);
975 trace_dump_arg(uint, num_textures);
976 trace_dump_arg_array(ptr, textures, num_textures);
978 pipe->set_fragment_sampler_textures(pipe, num_textures, textures);
980 trace_dump_call_end();
985 trace_context_set_vertex_sampler_textures(struct pipe_context *_pipe,
986 unsigned num_textures,
987 struct pipe_texture **textures)
989 struct trace_context *tr_ctx = trace_context(_pipe);
990 struct trace_texture *tr_tex;
991 struct pipe_context *pipe = tr_ctx->pipe;
992 struct pipe_texture *unwrapped_textures[PIPE_MAX_VERTEX_SAMPLERS];
995 tr_ctx->curr.num_vert_texs = num_textures;
996 for(i = 0; i < num_textures; ++i) {
997 tr_tex = trace_texture(textures[i]);
998 tr_ctx->curr.vert_tex[i] = tr_tex;
999 unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
1001 textures = unwrapped_textures;
1003 trace_dump_call_begin("pipe_context", "set_vertex_sampler_textures");
1005 trace_dump_arg(ptr, pipe);
1006 trace_dump_arg(uint, num_textures);
1007 trace_dump_arg_array(ptr, textures, num_textures);
1009 pipe->set_vertex_sampler_textures(pipe, num_textures, textures);
1011 trace_dump_call_end();
1016 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1017 unsigned num_buffers,
1018 const struct pipe_vertex_buffer *buffers)
1020 struct trace_context *tr_ctx = trace_context(_pipe);
1021 struct pipe_context *pipe = tr_ctx->pipe;
1024 for(i = 0; i < num_buffers; ++i)
1025 trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
1027 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1029 trace_dump_arg(ptr, pipe);
1030 trace_dump_arg(uint, num_buffers);
1032 trace_dump_arg_begin("buffers");
1033 trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1034 trace_dump_arg_end();
1037 struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
1038 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1039 for (i = 0; i < num_buffers; i++)
1040 _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
1041 pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1044 pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1047 trace_dump_call_end();
1052 trace_context_set_vertex_elements(struct pipe_context *_pipe,
1053 unsigned num_elements,
1054 const struct pipe_vertex_element *elements)
1056 struct trace_context *tr_ctx = trace_context(_pipe);
1057 struct pipe_context *pipe = tr_ctx->pipe;
1059 trace_dump_call_begin("pipe_context", "set_vertex_elements");
1061 trace_dump_arg(ptr, pipe);
1062 trace_dump_arg(uint, num_elements);
1064 trace_dump_arg_begin("elements");
1065 trace_dump_struct_array(vertex_element, elements, num_elements);
1066 trace_dump_arg_end();
1068 pipe->set_vertex_elements(pipe, num_elements, elements);
1070 trace_dump_call_end();
1075 trace_context_surface_copy(struct pipe_context *_pipe,
1076 struct pipe_surface *dest,
1077 unsigned destx, unsigned desty,
1078 struct pipe_surface *src,
1079 unsigned srcx, unsigned srcy,
1080 unsigned width, unsigned height)
1082 struct trace_context *tr_ctx = trace_context(_pipe);
1083 struct pipe_context *pipe = tr_ctx->pipe;
1085 dest = trace_surface_unwrap(tr_ctx, dest);
1086 src = trace_surface_unwrap(tr_ctx, src);
1088 trace_dump_call_begin("pipe_context", "surface_copy");
1090 trace_dump_arg(ptr, pipe);
1091 trace_dump_arg(ptr, dest);
1092 trace_dump_arg(uint, destx);
1093 trace_dump_arg(uint, desty);
1094 trace_dump_arg(ptr, src);
1095 trace_dump_arg(uint, srcx);
1096 trace_dump_arg(uint, srcy);
1097 trace_dump_arg(uint, width);
1098 trace_dump_arg(uint, height);
1100 pipe->surface_copy(pipe,
1102 src, srcx, srcy, width, height);
1104 trace_dump_call_end();
1109 trace_context_surface_fill(struct pipe_context *_pipe,
1110 struct pipe_surface *dst,
1111 unsigned dstx, unsigned dsty,
1112 unsigned width, unsigned height,
1115 struct trace_context *tr_ctx = trace_context(_pipe);
1116 struct pipe_context *pipe = tr_ctx->pipe;
1118 dst = trace_surface_unwrap(tr_ctx, dst);
1120 trace_dump_call_begin("pipe_context", "surface_fill");
1122 trace_dump_arg(ptr, pipe);
1123 trace_dump_arg(ptr, dst);
1124 trace_dump_arg(uint, dstx);
1125 trace_dump_arg(uint, dsty);
1126 trace_dump_arg(uint, width);
1127 trace_dump_arg(uint, height);
1129 pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);
1131 trace_dump_call_end();
1136 trace_context_clear(struct pipe_context *_pipe,
1142 struct trace_context *tr_ctx = trace_context(_pipe);
1143 struct pipe_context *pipe = tr_ctx->pipe;
1145 trace_dump_call_begin("pipe_context", "clear");
1147 trace_dump_arg(ptr, pipe);
1148 trace_dump_arg(uint, buffers);
1149 trace_dump_arg_array(float, rgba, 4);
1150 trace_dump_arg(float, depth);
1151 trace_dump_arg(uint, stencil);
1153 pipe->clear(pipe, buffers, rgba, depth, stencil);
1155 trace_dump_call_end();
1160 trace_context_flush(struct pipe_context *_pipe,
1162 struct pipe_fence_handle **fence)
1164 struct trace_context *tr_ctx = trace_context(_pipe);
1165 struct pipe_context *pipe = tr_ctx->pipe;
1167 trace_dump_call_begin("pipe_context", "flush");
1169 trace_dump_arg(ptr, pipe);
1170 trace_dump_arg(uint, flags);
1172 pipe->flush(pipe, flags, fence);
1175 trace_dump_ret(ptr, *fence);
1177 trace_dump_call_end();
1182 trace_context_destroy(struct pipe_context *_pipe)
1184 struct trace_screen *tr_scr = trace_screen(_pipe->screen);
1185 struct trace_context *tr_ctx = trace_context(_pipe);
1186 struct pipe_context *pipe = tr_ctx->pipe;
1188 trace_dump_call_begin("pipe_context", "destroy");
1189 trace_dump_arg(ptr, pipe);
1190 trace_dump_call_end();
1192 trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
1194 pipe->destroy(pipe);
1200 trace_is_texture_referenced( struct pipe_context *_pipe,
1201 struct pipe_texture *_texture,
1202 unsigned face, unsigned level)
1204 struct trace_context *tr_ctx = trace_context(_pipe);
1205 struct trace_texture *tr_tex = trace_texture(_texture);
1206 struct pipe_context *pipe = tr_ctx->pipe;
1207 struct pipe_texture *texture = tr_tex->texture;
1208 unsigned int referenced;
1210 trace_dump_call_begin("pipe_context", "is_texture_referenced");
1211 trace_dump_arg(ptr, pipe);
1212 trace_dump_arg(ptr, texture);
1213 trace_dump_arg(uint, face);
1214 trace_dump_arg(uint, level);
1216 referenced = pipe->is_texture_referenced(pipe, texture, face, level);
1218 trace_dump_ret(uint, referenced);
1219 trace_dump_call_end();
1225 trace_is_buffer_referenced( struct pipe_context *_pipe,
1226 struct pipe_buffer *_buf)
1228 struct trace_context *tr_ctx = trace_context(_pipe);
1229 struct trace_buffer *tr_buf = trace_buffer(_buf);
1230 struct pipe_context *pipe = tr_ctx->pipe;
1231 struct pipe_buffer *buf = tr_buf->buffer;
1232 unsigned int referenced;
1234 trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1235 trace_dump_arg(ptr, pipe);
1236 trace_dump_arg(ptr, buf);
1238 referenced = pipe->is_buffer_referenced(pipe, buf);
1240 trace_dump_ret(uint, referenced);
1241 trace_dump_call_end();
1246 static const struct debug_named_value rbug_blocker_flags[] = {
1252 struct pipe_context *
1253 trace_context_create(struct pipe_screen *_screen,
1254 struct pipe_context *pipe)
1256 struct trace_screen *tr_scr;
1257 struct trace_context *tr_ctx;
1258 struct pipe_screen *screen;
1263 if(!trace_enabled())
1266 tr_scr = trace_screen(_screen);
1267 screen = tr_scr->screen;
1269 tr_ctx = CALLOC_STRUCT(trace_context);
1273 tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
1276 pipe_mutex_init(tr_ctx->draw_mutex);
1277 pipe_condvar_init(tr_ctx->draw_cond);
1278 pipe_mutex_init(tr_ctx->list_mutex);
1279 make_empty_list(&tr_ctx->shaders);
1281 tr_ctx->base.winsys = _screen->winsys;
1282 tr_ctx->base.screen = _screen;
1283 tr_ctx->base.destroy = trace_context_destroy;
1284 tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1285 tr_ctx->base.draw_elements = trace_context_draw_elements;
1286 tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1287 tr_ctx->base.create_query = trace_context_create_query;
1288 tr_ctx->base.destroy_query = trace_context_destroy_query;
1289 tr_ctx->base.begin_query = trace_context_begin_query;
1290 tr_ctx->base.end_query = trace_context_end_query;
1291 tr_ctx->base.get_query_result = trace_context_get_query_result;
1292 tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1293 tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1294 tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1295 tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1296 tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1297 tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1298 tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1299 tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1300 tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1301 tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1302 tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1303 tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1304 tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1305 tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1306 tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1307 tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1308 tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1309 tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1310 tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1311 tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1312 tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1313 tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1314 tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1315 tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1316 tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1317 tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1318 tr_ctx->base.set_fragment_sampler_textures = trace_context_set_fragment_sampler_textures;
1319 tr_ctx->base.set_vertex_sampler_textures = trace_context_set_vertex_sampler_textures;
1320 tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1321 tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
1322 if (pipe->surface_copy)
1323 tr_ctx->base.surface_copy = trace_context_surface_copy;
1324 if (pipe->surface_fill)
1325 tr_ctx->base.surface_fill = trace_context_surface_fill;
1326 tr_ctx->base.clear = trace_context_clear;
1327 tr_ctx->base.flush = trace_context_flush;
1328 tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
1329 tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
1331 tr_ctx->pipe = pipe;
1333 trace_dump_call_begin("", "pipe_context_create");
1334 trace_dump_arg(ptr, screen);
1335 trace_dump_ret(ptr, pipe);
1336 trace_dump_call_end();
1338 trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
1340 return &tr_ctx->base;