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