tr_context.c revision 9dee60969df7ff263e05430e69ef26982fe2bd94 
1/**************************************************************************
2 *
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28#include "pipe/p_util.h"
29
30#include "tr_stream.h"
31#include "tr_dump.h"
32#include "tr_state.h"
33#include "tr_screen.h"
34#include "tr_context.h"
35
36
37static INLINE void
38trace_context_set_edgeflags(struct pipe_context *_pipe,
39                            const unsigned *bitfield)
40{
41   struct trace_context *tr_ctx = trace_context(_pipe);
42   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
43   struct trace_stream *stream = tr_scr->stream;
44   struct pipe_context *pipe = tr_ctx->pipe;
45
46   trace_dump_call_begin(stream, "pipe_context", "set_edgeflags");
47
48   trace_dump_arg(stream, ptr, pipe);
49   /* FIXME: we don't know how big this array is */
50   trace_dump_arg(stream, ptr, bitfield);
51
52   pipe->set_edgeflags(pipe, bitfield);;
53
54   trace_dump_call_end(stream);
55}
56
57
58static INLINE boolean
59trace_context_draw_arrays(struct pipe_context *_pipe,
60                          unsigned mode, unsigned start, unsigned count)
61{
62   struct trace_context *tr_ctx = trace_context(_pipe);
63   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
64   struct trace_stream *stream = tr_scr->stream;
65   struct pipe_context *pipe = tr_ctx->pipe;
66   boolean result;
67
68   trace_dump_call_begin(stream, "pipe_context", "draw_arrays");
69
70   trace_dump_arg(stream, ptr, pipe);
71   trace_dump_arg(stream, uint, mode);
72   trace_dump_arg(stream, uint, start);
73   trace_dump_arg(stream, uint, count);
74
75   result = pipe->draw_arrays(pipe, mode, start, count);;
76
77   trace_dump_ret(stream, bool, result);
78
79   trace_dump_call_end(stream);
80
81   return result;
82}
83
84
85static INLINE boolean
86trace_context_draw_elements(struct pipe_context *_pipe,
87                          struct pipe_buffer *indexBuffer,
88                          unsigned indexSize,
89                          unsigned mode, unsigned start, unsigned count)
90{
91   struct trace_context *tr_ctx = trace_context(_pipe);
92   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
93   struct trace_stream *stream = tr_scr->stream;
94   struct pipe_context *pipe = tr_ctx->pipe;
95   boolean result;
96
97   trace_dump_call_begin(stream, "pipe_context", "draw_elements");
98
99   trace_dump_arg(stream, ptr, pipe);
100   trace_dump_arg(stream, ptr, indexBuffer);
101   trace_dump_arg(stream, uint, indexSize);
102   trace_dump_arg(stream, uint, mode);
103   trace_dump_arg(stream, uint, start);
104   trace_dump_arg(stream, uint, count);
105
106   result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);;
107
108   trace_dump_ret(stream, bool, result);
109
110   trace_dump_call_end(stream);
111
112   return result;
113}
114
115
116static INLINE boolean
117trace_context_draw_range_elements(struct pipe_context *_pipe,
118                                  struct pipe_buffer *indexBuffer,
119                                  unsigned indexSize,
120                                  unsigned minIndex,
121                                  unsigned maxIndex,
122                                  unsigned mode,
123                                  unsigned start,
124                                  unsigned count)
125{
126   struct trace_context *tr_ctx = trace_context(_pipe);
127   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
128   struct trace_stream *stream = tr_scr->stream;
129   struct pipe_context *pipe = tr_ctx->pipe;
130   boolean result;
131
132   trace_dump_call_begin(stream, "pipe_context", "draw_range_elements");
133
134   trace_dump_arg(stream, ptr, pipe);
135   trace_dump_arg(stream, ptr, indexBuffer);
136   trace_dump_arg(stream, uint, indexSize);
137   trace_dump_arg(stream, uint, minIndex);
138   trace_dump_arg(stream, uint, maxIndex);
139   trace_dump_arg(stream, uint, mode);
140   trace_dump_arg(stream, uint, start);
141   trace_dump_arg(stream, uint, count);
142
143   result = pipe->draw_range_elements(pipe,
144                                      indexBuffer,
145                                      indexSize, minIndex, maxIndex,
146                                      mode, start, count);
147
148   trace_dump_ret(stream, bool, result);
149
150   trace_dump_call_end(stream);
151
152   return result;
153}
154
155
156static INLINE struct pipe_query *
157trace_context_create_query(struct pipe_context *_pipe,
158                           unsigned query_type)
159{
160   struct trace_context *tr_ctx = trace_context(_pipe);
161   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
162   struct trace_stream *stream = tr_scr->stream;
163   struct pipe_context *pipe = tr_ctx->pipe;
164   struct pipe_query *result;
165
166   trace_dump_call_begin(stream, "pipe_context", "create_query");
167
168   trace_dump_arg(stream, ptr, pipe);
169   trace_dump_arg(stream, uint, query_type);
170
171   result = pipe->create_query(pipe, query_type);;
172
173   trace_dump_ret(stream, ptr, result);
174
175   trace_dump_call_end(stream);
176
177   return result;
178}
179
180
181static INLINE void
182trace_context_destroy_query(struct pipe_context *_pipe,
183                            struct pipe_query *query)
184{
185   struct trace_context *tr_ctx = trace_context(_pipe);
186   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
187   struct trace_stream *stream = tr_scr->stream;
188   struct pipe_context *pipe = tr_ctx->pipe;
189
190   trace_dump_call_begin(stream, "pipe_context", "destroy_query");
191
192   trace_dump_arg(stream, ptr, pipe);
193   trace_dump_arg(stream, ptr, query);
194
195   pipe->destroy_query(pipe, query);;
196
197   trace_dump_call_end(stream);
198}
199
200
201static INLINE void
202trace_context_begin_query(struct pipe_context *_pipe,
203                          struct pipe_query *query)
204{
205   struct trace_context *tr_ctx = trace_context(_pipe);
206   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
207   struct trace_stream *stream = tr_scr->stream;
208   struct pipe_context *pipe = tr_ctx->pipe;
209
210   trace_dump_call_begin(stream, "pipe_context", "begin_query");
211
212   trace_dump_arg(stream, ptr, pipe);
213   trace_dump_arg(stream, ptr, query);
214
215   pipe->begin_query(pipe, query);;
216
217   trace_dump_call_end(stream);
218}
219
220
221static INLINE void
222trace_context_end_query(struct pipe_context *_pipe,
223                        struct pipe_query *query)
224{
225   struct trace_context *tr_ctx = trace_context(_pipe);
226   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
227   struct trace_stream *stream = tr_scr->stream;
228   struct pipe_context *pipe = tr_ctx->pipe;
229
230   trace_dump_call_begin(stream, "pipe_context", "end_query");
231
232   trace_dump_arg(stream, ptr, pipe);
233   trace_dump_arg(stream, ptr, query);
234
235   pipe->end_query(pipe, query);
236
237   trace_dump_call_end(stream);
238}
239
240
241static INLINE boolean
242trace_context_get_query_result(struct pipe_context *_pipe,
243                               struct pipe_query *query,
244                               boolean wait,
245                               uint64 *presult)
246{
247   struct trace_context *tr_ctx = trace_context(_pipe);
248   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
249   struct trace_stream *stream = tr_scr->stream;
250   struct pipe_context *pipe = tr_ctx->pipe;
251   uint64 result;
252   boolean _result;
253
254   trace_dump_call_begin(stream, "pipe_context", "get_query_result");
255
256   trace_dump_arg(stream, ptr, pipe);
257
258   _result = pipe->get_query_result(pipe, query, wait, presult);;
259   result = *presult;
260
261   trace_dump_arg(stream, uint, result);
262   trace_dump_ret(stream, bool, _result);
263
264   trace_dump_call_end(stream);
265
266   return _result;
267}
268
269
270static INLINE void *
271trace_context_create_blend_state(struct pipe_context *_pipe,
272                                 const struct pipe_blend_state *state)
273{
274   struct trace_context *tr_ctx = trace_context(_pipe);
275   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
276   struct trace_stream *stream = tr_scr->stream;
277   struct pipe_context *pipe = tr_ctx->pipe;
278   void * result;
279
280   trace_dump_call_begin(stream, "pipe_context", "create_blend_state");
281
282   trace_dump_arg(stream, ptr, pipe);
283   trace_dump_arg(stream, blend_state, state);
284
285   result = pipe->create_blend_state(pipe, state);;
286
287   trace_dump_call_end(stream);
288
289   return result;
290}
291
292
293static INLINE void
294trace_context_bind_blend_state(struct pipe_context *_pipe,
295                               void *state)
296{
297   struct trace_context *tr_ctx = trace_context(_pipe);
298   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
299   struct trace_stream *stream = tr_scr->stream;
300   struct pipe_context *pipe = tr_ctx->pipe;
301
302   trace_dump_call_begin(stream, "pipe_context", "bind_blend_state");
303
304   trace_dump_arg(stream, ptr, pipe);
305   trace_dump_arg(stream, ptr, state);
306
307   pipe->bind_blend_state(pipe, state);;
308
309   trace_dump_call_end(stream);
310}
311
312
313static INLINE void
314trace_context_delete_blend_state(struct pipe_context *_pipe,
315                                 void *state)
316{
317   struct trace_context *tr_ctx = trace_context(_pipe);
318   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
319   struct trace_stream *stream = tr_scr->stream;
320   struct pipe_context *pipe = tr_ctx->pipe;
321
322   trace_dump_call_begin(stream, "pipe_context", "delete_blend_state");
323
324   trace_dump_arg(stream, ptr, pipe);
325   trace_dump_arg(stream, ptr, state);
326
327   pipe->delete_blend_state(pipe, state);;
328
329   trace_dump_call_end(stream);
330}
331
332
333static INLINE void *
334trace_context_create_sampler_state(struct pipe_context *_pipe,
335                                   const struct pipe_sampler_state *state)
336{
337   struct trace_context *tr_ctx = trace_context(_pipe);
338   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
339   struct trace_stream *stream = tr_scr->stream;
340   struct pipe_context *pipe = tr_ctx->pipe;
341   void * result;
342
343   trace_dump_call_begin(stream, "pipe_context", "create_sampler_state");
344
345   trace_dump_arg(stream, ptr, pipe);
346   trace_dump_arg(stream, ptr, state);
347
348   result = pipe->create_sampler_state(pipe, state);;
349
350   trace_dump_ret(stream, sampler_state, result);
351
352   trace_dump_call_end(stream);
353
354   return result;
355}
356
357
358static INLINE void
359trace_context_bind_sampler_states(struct pipe_context *_pipe,
360                                  unsigned num_states, void **states)
361{
362   struct trace_context *tr_ctx = trace_context(_pipe);
363   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
364   struct trace_stream *stream = tr_scr->stream;
365   struct pipe_context *pipe = tr_ctx->pipe;
366
367   trace_dump_call_begin(stream, "pipe_context", "bind_sampler_states");
368
369   trace_dump_arg(stream, ptr, pipe);
370   trace_dump_arg(stream, uint, num_states);
371   trace_dump_arg_array(stream, ptr, states, num_states);
372
373   pipe->bind_sampler_states(pipe, num_states, states);;
374
375   trace_dump_call_end(stream);
376}
377
378
379static INLINE void
380trace_context_delete_sampler_state(struct pipe_context *_pipe,
381                                   void *state)
382{
383   struct trace_context *tr_ctx = trace_context(_pipe);
384   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
385   struct trace_stream *stream = tr_scr->stream;
386   struct pipe_context *pipe = tr_ctx->pipe;
387
388   trace_dump_call_begin(stream, "pipe_context", "delete_sampler_state");
389
390   trace_dump_arg(stream, ptr, pipe);
391   trace_dump_arg(stream, ptr, state);
392
393   pipe->delete_sampler_state(pipe, state);;
394
395   trace_dump_call_end(stream);
396}
397
398
399static INLINE void *
400trace_context_create_rasterizer_state(struct pipe_context *_pipe,
401                                      const struct pipe_rasterizer_state *state)
402{
403   struct trace_context *tr_ctx = trace_context(_pipe);
404   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
405   struct trace_stream *stream = tr_scr->stream;
406   struct pipe_context *pipe = tr_ctx->pipe;
407   void * result;
408
409   trace_dump_call_begin(stream, "pipe_context", "create_rasterizer_state");
410
411   trace_dump_arg(stream, ptr, pipe);
412   trace_dump_arg(stream, rasterizer_state, state);
413
414   result = pipe->create_rasterizer_state(pipe, state);;
415
416   trace_dump_ret(stream, ptr, result);
417
418   trace_dump_call_end(stream);
419
420   return result;
421}
422
423
424static INLINE void
425trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
426                                    void *state)
427{
428   struct trace_context *tr_ctx = trace_context(_pipe);
429   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
430   struct trace_stream *stream = tr_scr->stream;
431   struct pipe_context *pipe = tr_ctx->pipe;
432
433   trace_dump_call_begin(stream, "pipe_context", "bind_rasterizer_state");
434
435   trace_dump_arg(stream, ptr, pipe);
436   trace_dump_arg(stream, ptr, state);
437
438   pipe->bind_rasterizer_state(pipe, state);;
439
440   trace_dump_call_end(stream);
441}
442
443
444static INLINE void
445trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
446                                      void *state)
447{
448   struct trace_context *tr_ctx = trace_context(_pipe);
449   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
450   struct trace_stream *stream = tr_scr->stream;
451   struct pipe_context *pipe = tr_ctx->pipe;
452
453   trace_dump_call_begin(stream, "pipe_context", "delete_rasterizer_state");
454
455   trace_dump_arg(stream, ptr, pipe);
456   trace_dump_arg(stream, ptr, state);
457
458   pipe->delete_rasterizer_state(pipe, state);;
459
460   trace_dump_call_end(stream);
461}
462
463
464static INLINE void *
465trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
466                                               const struct pipe_depth_stencil_alpha_state *state)
467{
468   struct trace_context *tr_ctx = trace_context(_pipe);
469   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
470   struct trace_stream *stream = tr_scr->stream;
471   struct pipe_context *pipe = tr_ctx->pipe;
472   void * result;
473
474   trace_dump_call_begin(stream, "pipe_context", "create_depth_stencil_alpha_state");
475
476   result = pipe->create_depth_stencil_alpha_state(pipe, state);;
477
478   trace_dump_ret(stream, ptr, result);
479   trace_dump_arg(stream, depth_stencil_alpha_state, state);
480
481   trace_dump_call_end(stream);
482
483   return result;
484}
485
486
487static INLINE void
488trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
489                                             void *state)
490{
491   struct trace_context *tr_ctx = trace_context(_pipe);
492   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
493   struct trace_stream *stream = tr_scr->stream;
494   struct pipe_context *pipe = tr_ctx->pipe;
495
496   trace_dump_call_begin(stream, "pipe_context", "bind_depth_stencil_alpha_state");
497
498   trace_dump_arg(stream, ptr, pipe);
499   trace_dump_arg(stream, ptr, state);
500
501   pipe->bind_depth_stencil_alpha_state(pipe, state);;
502
503   trace_dump_call_end(stream);
504}
505
506
507static INLINE void
508trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
509                                               void *state)
510{
511   struct trace_context *tr_ctx = trace_context(_pipe);
512   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
513   struct trace_stream *stream = tr_scr->stream;
514   struct pipe_context *pipe = tr_ctx->pipe;
515
516   trace_dump_call_begin(stream, "pipe_context", "delete_depth_stencil_alpha_state");
517
518   trace_dump_arg(stream, ptr, pipe);
519   trace_dump_arg(stream, ptr, state);
520
521   pipe->delete_depth_stencil_alpha_state(pipe, state);;
522
523   trace_dump_call_end(stream);
524}
525
526
527static INLINE void *
528trace_context_create_fs_state(struct pipe_context *_pipe,
529                              const struct pipe_shader_state *state)
530{
531   struct trace_context *tr_ctx = trace_context(_pipe);
532   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
533   struct trace_stream *stream = tr_scr->stream;
534   struct pipe_context *pipe = tr_ctx->pipe;
535   void * result;
536
537   trace_dump_call_begin(stream, "pipe_context", "create_fs_state");
538
539   trace_dump_arg(stream, ptr, pipe);
540   trace_dump_arg(stream, shader_state, state);
541
542   result = pipe->create_fs_state(pipe, state);;
543
544   trace_dump_ret(stream, ptr, result);
545
546   trace_dump_call_end(stream);
547
548   return result;
549}
550
551
552static INLINE void
553trace_context_bind_fs_state(struct pipe_context *_pipe,
554                            void *state)
555{
556   struct trace_context *tr_ctx = trace_context(_pipe);
557   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
558   struct trace_stream *stream = tr_scr->stream;
559   struct pipe_context *pipe = tr_ctx->pipe;
560
561   trace_dump_call_begin(stream, "pipe_context", "bind_fs_state");
562
563   trace_dump_arg(stream, ptr, pipe);
564   trace_dump_arg(stream, ptr, state);
565
566   pipe->bind_fs_state(pipe, state);;
567
568   trace_dump_call_end(stream);
569}
570
571
572static INLINE void
573trace_context_delete_fs_state(struct pipe_context *_pipe,
574                              void *state)
575{
576   struct trace_context *tr_ctx = trace_context(_pipe);
577   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
578   struct trace_stream *stream = tr_scr->stream;
579   struct pipe_context *pipe = tr_ctx->pipe;
580
581   trace_dump_call_begin(stream, "pipe_context", "delete_fs_state");
582
583   trace_dump_arg(stream, ptr, pipe);
584   trace_dump_arg(stream, ptr, state);
585
586   pipe->delete_fs_state(pipe, state);;
587
588   trace_dump_call_end(stream);
589}
590
591
592static INLINE void *
593trace_context_create_vs_state(struct pipe_context *_pipe,
594                              const struct pipe_shader_state *state)
595{
596   struct trace_context *tr_ctx = trace_context(_pipe);
597   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
598   struct trace_stream *stream = tr_scr->stream;
599   struct pipe_context *pipe = tr_ctx->pipe;
600   void * result;
601
602   trace_dump_call_begin(stream, "pipe_context", "create_vs_state");
603
604   trace_dump_arg(stream, ptr, pipe);
605   trace_dump_arg(stream, shader_state, state);
606
607   result = pipe->create_vs_state(pipe, state);;
608
609   trace_dump_ret(stream, ptr, result);
610
611   trace_dump_call_end(stream);
612
613   return result;
614}
615
616
617static INLINE void
618trace_context_bind_vs_state(struct pipe_context *_pipe,
619                            void *state)
620{
621   struct trace_context *tr_ctx = trace_context(_pipe);
622   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
623   struct trace_stream *stream = tr_scr->stream;
624   struct pipe_context *pipe = tr_ctx->pipe;
625
626   trace_dump_call_begin(stream, "pipe_context", "bind_vs_state");
627
628   trace_dump_arg(stream, ptr, pipe);
629   trace_dump_arg(stream, ptr, state);
630
631   pipe->bind_vs_state(pipe, state);;
632
633   trace_dump_call_end(stream);
634}
635
636
637static INLINE void
638trace_context_delete_vs_state(struct pipe_context *_pipe,
639                              void *state)
640{
641   struct trace_context *tr_ctx = trace_context(_pipe);
642   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
643   struct trace_stream *stream = tr_scr->stream;
644   struct pipe_context *pipe = tr_ctx->pipe;
645
646   trace_dump_call_begin(stream, "pipe_context", "delete_vs_state");
647
648   trace_dump_arg(stream, ptr, pipe);
649   trace_dump_arg(stream, ptr, state);
650
651   pipe->delete_vs_state(pipe, state);;
652
653   trace_dump_call_end(stream);
654}
655
656
657static INLINE void
658trace_context_set_blend_color(struct pipe_context *_pipe,
659                              const struct pipe_blend_color *state)
660{
661   struct trace_context *tr_ctx = trace_context(_pipe);
662   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
663   struct trace_stream *stream = tr_scr->stream;
664   struct pipe_context *pipe = tr_ctx->pipe;
665
666   trace_dump_call_begin(stream, "pipe_context", "set_blend_color");
667
668   trace_dump_arg(stream, ptr, pipe);
669   trace_dump_arg(stream, blend_color, state);
670
671   pipe->set_blend_color(pipe, state);;
672
673   trace_dump_call_end(stream);
674}
675
676
677static INLINE void
678trace_context_set_clip_state(struct pipe_context *_pipe,
679                             const struct pipe_clip_state *state)
680{
681   struct trace_context *tr_ctx = trace_context(_pipe);
682   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
683   struct trace_stream *stream = tr_scr->stream;
684   struct pipe_context *pipe = tr_ctx->pipe;
685
686   trace_dump_call_begin(stream, "pipe_context", "set_clip_state");
687
688   trace_dump_arg(stream, ptr, pipe);
689   trace_dump_arg(stream, clip_state, state);
690
691   pipe->set_clip_state(pipe, state);;
692
693   trace_dump_call_end(stream);
694}
695
696
697static INLINE void
698trace_context_set_constant_buffer(struct pipe_context *_pipe,
699                                  uint shader, uint index,
700                                  const struct pipe_constant_buffer *buffer)
701{
702   struct trace_context *tr_ctx = trace_context(_pipe);
703   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
704   struct trace_stream *stream = tr_scr->stream;
705   struct pipe_context *pipe = tr_ctx->pipe;
706
707   trace_dump_call_begin(stream, "pipe_context", "set_constant_buffer");
708
709   trace_dump_arg(stream, ptr, pipe);
710   trace_dump_arg(stream, uint, shader);
711   trace_dump_arg(stream, uint, index);
712   trace_dump_arg(stream, constant_buffer, buffer);
713
714   pipe->set_constant_buffer(pipe, shader, index, buffer);;
715
716   trace_dump_call_end(stream);
717}
718
719
720static INLINE void
721trace_context_set_framebuffer_state(struct pipe_context *_pipe,
722                                    const struct pipe_framebuffer_state *state)
723{
724   struct trace_context *tr_ctx = trace_context(_pipe);
725   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
726   struct trace_stream *stream = tr_scr->stream;
727   struct pipe_context *pipe = tr_ctx->pipe;
728
729   trace_dump_call_begin(stream, "pipe_context", "set_framebuffer_state");
730
731   trace_dump_arg(stream, ptr, pipe);
732   trace_dump_arg(stream, framebuffer_state, state);
733
734   pipe->set_framebuffer_state(pipe, state);;
735
736   trace_dump_call_end(stream);
737}
738
739
740static INLINE void
741trace_context_set_polygon_stipple(struct pipe_context *_pipe,
742                                  const struct pipe_poly_stipple *state)
743{
744   struct trace_context *tr_ctx = trace_context(_pipe);
745   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
746   struct trace_stream *stream = tr_scr->stream;
747   struct pipe_context *pipe = tr_ctx->pipe;
748
749   trace_dump_call_begin(stream, "pipe_context", "set_polygon_stipple");
750
751   trace_dump_arg(stream, ptr, pipe);
752   trace_dump_arg(stream, poly_stipple, state);
753
754   pipe->set_polygon_stipple(pipe, state);;
755
756   trace_dump_call_end(stream);
757}
758
759
760static INLINE void
761trace_context_set_scissor_state(struct pipe_context *_pipe,
762                                const struct pipe_scissor_state *state)
763{
764   struct trace_context *tr_ctx = trace_context(_pipe);
765   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
766   struct trace_stream *stream = tr_scr->stream;
767   struct pipe_context *pipe = tr_ctx->pipe;
768
769   trace_dump_call_begin(stream, "pipe_context", "set_scissor_state");
770
771   trace_dump_arg(stream, ptr, pipe);
772   trace_dump_arg(stream, scissor_state, state);
773
774   pipe->set_scissor_state(pipe, state);;
775
776   trace_dump_call_end(stream);
777}
778
779
780static INLINE void
781trace_context_set_viewport_state(struct pipe_context *_pipe,
782                                 const struct pipe_viewport_state *state)
783{
784   struct trace_context *tr_ctx = trace_context(_pipe);
785   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
786   struct trace_stream *stream = tr_scr->stream;
787   struct pipe_context *pipe = tr_ctx->pipe;
788
789   trace_dump_call_begin(stream, "pipe_context", "set_viewport_state");
790
791   trace_dump_arg(stream, ptr, pipe);
792   trace_dump_arg(stream, viewport_state, state);
793
794   pipe->set_viewport_state(pipe, state);;
795
796   trace_dump_call_end(stream);
797}
798
799
800static INLINE void
801trace_context_set_sampler_textures(struct pipe_context *_pipe,
802                                   unsigned num_textures,
803                                   struct pipe_texture **textures)
804{
805   struct trace_context *tr_ctx = trace_context(_pipe);
806   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
807   struct trace_stream *stream = tr_scr->stream;
808   struct pipe_context *pipe = tr_ctx->pipe;
809
810   trace_dump_call_begin(stream, "pipe_context", "set_sampler_textures");
811
812   trace_dump_arg(stream, ptr, pipe);
813   trace_dump_arg(stream, uint, num_textures);
814   trace_dump_arg_array(stream, ptr, textures, num_textures);
815
816   pipe->set_sampler_textures(pipe, num_textures, textures);;
817
818   trace_dump_call_end(stream);
819}
820
821
822static INLINE void
823trace_context_set_vertex_buffers(struct pipe_context *_pipe,
824                                 unsigned num_buffers,
825                                 const struct pipe_vertex_buffer *buffers)
826{
827   struct trace_context *tr_ctx = trace_context(_pipe);
828   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
829   struct trace_stream *stream = tr_scr->stream;
830   struct pipe_context *pipe = tr_ctx->pipe;
831
832   trace_dump_call_begin(stream, "pipe_context", "set_vertex_buffers");
833
834   trace_dump_arg(stream, ptr, pipe);
835   trace_dump_arg(stream, uint, num_buffers);
836
837   trace_dump_arg_begin(stream, "buffers");
838   trace_dump_struct_array(stream, vertex_buffer, buffers, num_buffers);
839   trace_dump_arg_end(stream);
840
841   pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
842
843   trace_dump_call_end(stream);
844}
845
846
847static INLINE void
848trace_context_set_vertex_elements(struct pipe_context *_pipe,
849                                  unsigned num_elements,
850                                  const struct pipe_vertex_element *elements)
851{
852   struct trace_context *tr_ctx = trace_context(_pipe);
853   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
854   struct trace_stream *stream = tr_scr->stream;
855   struct pipe_context *pipe = tr_ctx->pipe;
856
857   trace_dump_call_begin(stream, "pipe_context", "set_vertex_elements");
858
859   trace_dump_arg(stream, ptr, pipe);
860   trace_dump_arg(stream, uint, num_elements);
861   trace_dump_arg(stream, ptr, elements);
862
863   trace_dump_arg_begin(stream, "elements");
864   trace_dump_struct_array(stream, vertex_element, elements, num_elements);
865   trace_dump_arg_end(stream);
866
867   pipe->set_vertex_elements(pipe, num_elements, elements);;
868
869   trace_dump_call_end(stream);
870}
871
872
873static INLINE void
874trace_context_surface_copy(struct pipe_context *_pipe,
875                           boolean do_flip,
876                           struct pipe_surface *dest,
877                           unsigned destx, unsigned desty,
878                           struct pipe_surface *src,
879                           unsigned srcx, unsigned srcy,
880                           unsigned width, unsigned height)
881{
882   struct trace_context *tr_ctx = trace_context(_pipe);
883   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
884   struct trace_stream *stream = tr_scr->stream;
885   struct pipe_context *pipe = tr_ctx->pipe;
886
887   trace_dump_call_begin(stream, "pipe_context", "surface_copy");
888
889   trace_dump_arg(stream, ptr, pipe);
890   trace_dump_arg(stream, bool, do_flip);
891   trace_dump_arg(stream, ptr, dest);
892   trace_dump_arg(stream, uint, destx);
893   trace_dump_arg(stream, uint, desty);
894   trace_dump_arg(stream, ptr, src);
895   trace_dump_arg(stream, uint, srcx);
896   trace_dump_arg(stream, uint, srcy);
897   trace_dump_arg(stream, uint, width);
898   trace_dump_arg(stream, uint, height);
899
900   pipe->surface_copy(pipe, do_flip,
901                      dest, destx, desty,
902                      src, srcx, srcy, width, height);
903
904   trace_dump_call_end(stream);
905}
906
907
908static INLINE void
909trace_context_surface_fill(struct pipe_context *_pipe,
910                           struct pipe_surface *dst,
911                           unsigned dstx, unsigned dsty,
912                           unsigned width, unsigned height,
913                           unsigned value)
914{
915   struct trace_context *tr_ctx = trace_context(_pipe);
916   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
917   struct trace_stream *stream = tr_scr->stream;
918   struct pipe_context *pipe = tr_ctx->pipe;
919
920   trace_dump_call_begin(stream, "pipe_context", "surface_fill");
921
922   trace_dump_arg(stream, ptr, pipe);
923   trace_dump_arg(stream, ptr, dst);
924   trace_dump_arg(stream, uint, dstx);
925   trace_dump_arg(stream, uint, dsty);
926   trace_dump_arg(stream, uint, width);
927   trace_dump_arg(stream, uint, height);
928
929   pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);;
930
931   trace_dump_call_end(stream);
932}
933
934
935static INLINE void
936trace_context_clear(struct pipe_context *_pipe,
937                    struct pipe_surface *surface,
938                    unsigned clearValue)
939{
940   struct trace_context *tr_ctx = trace_context(_pipe);
941   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
942   struct trace_stream *stream = tr_scr->stream;
943   struct pipe_context *pipe = tr_ctx->pipe;
944
945   trace_dump_call_begin(stream, "pipe_context", "clear");
946
947   trace_dump_arg(stream, ptr, pipe);
948   trace_dump_arg(stream, ptr, surface);
949   trace_dump_arg(stream, uint, clearValue);
950
951   pipe->clear(pipe, surface, clearValue);;
952
953   trace_dump_call_end(stream);
954}
955
956
957static INLINE void
958trace_context_flush(struct pipe_context *_pipe,
959                    unsigned flags,
960                    struct pipe_fence_handle **fence)
961{
962   struct trace_context *tr_ctx = trace_context(_pipe);
963   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
964   struct trace_stream *stream = tr_scr->stream;
965   struct pipe_context *pipe = tr_ctx->pipe;
966
967   trace_dump_call_begin(stream, "pipe_context", "flush");
968
969   trace_dump_arg(stream, ptr, pipe);
970   trace_dump_arg(stream, uint, flags);
971   trace_dump_arg(stream, ptr, fence);
972
973   pipe->flush(pipe, flags, fence);;
974
975   trace_dump_call_end(stream);
976}
977
978
979static INLINE void
980trace_context_destroy(struct pipe_context *_pipe)
981{
982   struct trace_context *tr_ctx = trace_context(_pipe);
983   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
984   struct trace_stream *stream = tr_scr->stream;
985   struct pipe_context *pipe = tr_ctx->pipe;
986
987   trace_dump_call_begin(stream, "pipe_context", "destroy");
988
989   trace_dump_arg(stream, ptr, pipe);
990
991   pipe->destroy(pipe);
992
993   trace_dump_call_end(stream);
994
995   FREE(tr_ctx);
996}
997
998
999struct pipe_context *
1000trace_context_create(struct pipe_context *pipe)
1001{
1002   struct trace_context *tr_ctx;
1003
1004   if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
1005      return pipe;
1006
1007   tr_ctx = CALLOC_STRUCT(trace_context);
1008   if(!tr_ctx)
1009      return NULL;
1010
1011   tr_ctx->base.winsys = pipe->winsys;
1012   tr_ctx->base.screen = pipe->screen;
1013   tr_ctx->base.destroy = trace_context_destroy;
1014   tr_ctx->base.set_edgeflags = trace_context_set_edgeflags;
1015   tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1016   tr_ctx->base.draw_elements = trace_context_draw_elements;
1017   tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1018   tr_ctx->base.create_query = trace_context_create_query;
1019   tr_ctx->base.destroy_query = trace_context_destroy_query;
1020   tr_ctx->base.begin_query = trace_context_begin_query;
1021   tr_ctx->base.end_query = trace_context_end_query;
1022   tr_ctx->base.get_query_result = trace_context_get_query_result;
1023   tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1024   tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1025   tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1026   tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1027   tr_ctx->base.bind_sampler_states = trace_context_bind_sampler_states;
1028   tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1029   tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1030   tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1031   tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1032   tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1033   tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1034   tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1035   tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1036   tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1037   tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1038   tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1039   tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1040   tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1041   tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1042   tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1043   tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1044   tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1045   tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1046   tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1047   tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1048   tr_ctx->base.set_sampler_textures = trace_context_set_sampler_textures;
1049   tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1050   tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
1051   tr_ctx->base.surface_copy = trace_context_surface_copy;
1052   tr_ctx->base.surface_fill = trace_context_surface_fill;
1053   tr_ctx->base.clear = trace_context_clear;
1054   tr_ctx->base.flush = trace_context_flush;
1055
1056   tr_ctx->pipe = pipe;
1057
1058   return &tr_ctx->base;
1059}
1060