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