tr_context.c revision 47bfbd452c93e6a8db013fb90d9f42210cf24889 
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_inlines.h"
29#include "util/u_memory.h"
30#include "util/u_simple_list.h"
31#include "util/u_format.h"
32
33#include "pipe/p_format.h"
34#include "pipe/p_screen.h"
35
36#include "tr_dump.h"
37#include "tr_dump_state.h"
38#include "tr_state.h"
39#include "tr_buffer.h"
40#include "tr_screen.h"
41#include "tr_texture.h"
42
43
44static INLINE struct pipe_buffer *
45trace_buffer_unwrap(struct trace_context *tr_ctx,
46                     struct pipe_buffer *buffer)
47{
48   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
49   struct trace_buffer *tr_buf;
50
51   if(!buffer)
52      return NULL;
53
54   tr_buf = trace_buffer(buffer);
55
56   assert(tr_buf->buffer);
57   assert(tr_buf->buffer->screen == tr_scr->screen);
58   (void) tr_scr;
59   return tr_buf->buffer;
60}
61
62
63static INLINE struct pipe_texture *
64trace_texture_unwrap(struct trace_context *tr_ctx,
65                     struct pipe_texture *texture)
66{
67   struct trace_texture *tr_tex;
68
69   if(!texture)
70      return NULL;
71
72   tr_tex = trace_texture(texture);
73
74   assert(tr_tex->texture);
75   return tr_tex->texture;
76}
77
78
79static INLINE struct pipe_surface *
80trace_surface_unwrap(struct trace_context *tr_ctx,
81                     struct pipe_surface *surface)
82{
83   struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
84   struct trace_surface *tr_surf;
85
86   if(!surface)
87      return NULL;
88
89   assert(surface->texture);
90   if(!surface->texture)
91      return surface;
92
93   tr_surf = trace_surface(surface);
94
95   assert(tr_surf->surface);
96   assert(tr_surf->surface->texture->screen == tr_scr->screen);
97   (void) tr_scr;
98   return tr_surf->surface;
99}
100
101
102static INLINE void
103trace_context_draw_block(struct trace_context *tr_ctx, int flag)
104{
105   int k;
106
107   pipe_mutex_lock(tr_ctx->draw_mutex);
108
109   if (tr_ctx->draw_blocker & flag) {
110      tr_ctx->draw_blocked |= flag;
111   } else if ((tr_ctx->draw_rule.blocker & flag) &&
112              (tr_ctx->draw_blocker & 4)) {
113      boolean block = FALSE;
114      debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
115                   (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
116                   (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
117                   (void *) tr_ctx->draw_rule.surf, 0,
118                   (void *) tr_ctx->draw_rule.sampler_view, 0);
119      if (tr_ctx->draw_rule.fs &&
120          tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
121         block = TRUE;
122      if (tr_ctx->draw_rule.vs &&
123          tr_ctx->draw_rule.vs == tr_ctx->curr.vs)
124         block = TRUE;
125      if (tr_ctx->draw_rule.surf &&
126          tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf)
127            block = TRUE;
128      if (tr_ctx->draw_rule.surf)
129         for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
130            if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
131               block = TRUE;
132      if (tr_ctx->draw_rule.sampler_view) {
133         for (k = 0; k < tr_ctx->curr.num_sampler_views; k++)
134            if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.sampler_views[k])
135               block = TRUE;
136         for (k = 0; k < tr_ctx->curr.num_vert_sampler_views; k++) {
137            if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.vert_sampler_views[k]) {
138               block = TRUE;
139            }
140         }
141      }
142
143      if (block)
144         tr_ctx->draw_blocked |= (flag | 4);
145   }
146
147   if (tr_ctx->draw_blocked)
148      trace_rbug_notify_draw_blocked(tr_ctx);
149
150   /* wait for rbug to clear the blocked flag */
151   while (tr_ctx->draw_blocked & flag) {
152      tr_ctx->draw_blocked |= flag;
153#ifdef PIPE_THREAD_HAVE_CONDVAR
154      pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex);
155#else
156      pipe_mutex_unlock(tr_ctx->draw_mutex);
157#ifdef PIPE_SUBSYSTEM_WINDOWS_USER
158      Sleep(1);
159#endif
160      pipe_mutex_lock(tr_ctx->draw_mutex);
161#endif
162   }
163
164   pipe_mutex_unlock(tr_ctx->draw_mutex);
165}
166
167static INLINE void
168trace_context_draw_arrays(struct pipe_context *_pipe,
169                          unsigned mode, unsigned start, unsigned count)
170{
171   struct trace_context *tr_ctx = trace_context(_pipe);
172   struct pipe_context *pipe = tr_ctx->pipe;
173
174   if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
175      return;
176
177   trace_context_draw_block(tr_ctx, 1);
178
179   trace_dump_call_begin("pipe_context", "draw_arrays");
180
181   trace_dump_arg(ptr, pipe);
182   trace_dump_arg(uint, mode);
183   trace_dump_arg(uint, start);
184   trace_dump_arg(uint, count);
185
186   pipe->draw_arrays(pipe, mode, start, count);
187
188   trace_dump_call_end();
189
190   trace_context_draw_block(tr_ctx, 2);
191}
192
193
194static INLINE void
195trace_context_draw_elements(struct pipe_context *_pipe,
196                          struct pipe_buffer *_indexBuffer,
197                          unsigned indexSize,
198                          unsigned mode, unsigned start, unsigned count)
199{
200   struct trace_context *tr_ctx = trace_context(_pipe);
201   struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
202   struct pipe_context *pipe = tr_ctx->pipe;
203   struct pipe_buffer *indexBuffer = tr_buf->buffer;
204
205   if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
206      return;
207
208   trace_context_draw_block(tr_ctx, 1);
209
210   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
211
212   trace_dump_call_begin("pipe_context", "draw_elements");
213
214   trace_dump_arg(ptr, pipe);
215   trace_dump_arg(ptr, indexBuffer);
216   trace_dump_arg(uint, indexSize);
217   trace_dump_arg(uint, mode);
218   trace_dump_arg(uint, start);
219   trace_dump_arg(uint, count);
220
221   pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);
222
223   trace_dump_call_end();
224
225   trace_context_draw_block(tr_ctx, 2);
226}
227
228
229static INLINE void
230trace_context_draw_range_elements(struct pipe_context *_pipe,
231                                  struct pipe_buffer *_indexBuffer,
232                                  unsigned indexSize,
233                                  unsigned minIndex,
234                                  unsigned maxIndex,
235                                  unsigned mode,
236                                  unsigned start,
237                                  unsigned count)
238{
239   struct trace_context *tr_ctx = trace_context(_pipe);
240   struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
241   struct pipe_context *pipe = tr_ctx->pipe;
242   struct pipe_buffer *indexBuffer = tr_buf->buffer;
243
244   if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
245      return;
246
247   trace_context_draw_block(tr_ctx, 1);
248
249   trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
250
251   trace_dump_call_begin("pipe_context", "draw_range_elements");
252
253   trace_dump_arg(ptr, pipe);
254   trace_dump_arg(ptr, indexBuffer);
255   trace_dump_arg(uint, indexSize);
256   trace_dump_arg(uint, minIndex);
257   trace_dump_arg(uint, maxIndex);
258   trace_dump_arg(uint, mode);
259   trace_dump_arg(uint, start);
260   trace_dump_arg(uint, count);
261
262   pipe->draw_range_elements(pipe,
263                             indexBuffer,
264                             indexSize, minIndex, maxIndex,
265                             mode, start, count);
266
267   trace_dump_call_end();
268
269   trace_context_draw_block(tr_ctx, 2);
270}
271
272
273static INLINE struct pipe_query *
274trace_context_create_query(struct pipe_context *_pipe,
275                           unsigned query_type)
276{
277   struct trace_context *tr_ctx = trace_context(_pipe);
278   struct pipe_context *pipe = tr_ctx->pipe;
279   struct pipe_query *result;
280
281   trace_dump_call_begin("pipe_context", "create_query");
282
283   trace_dump_arg(ptr, pipe);
284   trace_dump_arg(uint, query_type);
285
286   result = pipe->create_query(pipe, query_type);
287
288   trace_dump_ret(ptr, result);
289
290   trace_dump_call_end();
291
292   return result;
293}
294
295
296static INLINE void
297trace_context_destroy_query(struct pipe_context *_pipe,
298                            struct pipe_query *query)
299{
300   struct trace_context *tr_ctx = trace_context(_pipe);
301   struct pipe_context *pipe = tr_ctx->pipe;
302
303   trace_dump_call_begin("pipe_context", "destroy_query");
304
305   trace_dump_arg(ptr, pipe);
306   trace_dump_arg(ptr, query);
307
308   pipe->destroy_query(pipe, query);
309
310   trace_dump_call_end();
311}
312
313
314static INLINE void
315trace_context_begin_query(struct pipe_context *_pipe,
316                          struct pipe_query *query)
317{
318   struct trace_context *tr_ctx = trace_context(_pipe);
319   struct pipe_context *pipe = tr_ctx->pipe;
320
321   trace_dump_call_begin("pipe_context", "begin_query");
322
323   trace_dump_arg(ptr, pipe);
324   trace_dump_arg(ptr, query);
325
326   pipe->begin_query(pipe, query);
327
328   trace_dump_call_end();
329}
330
331
332static INLINE void
333trace_context_end_query(struct pipe_context *_pipe,
334                        struct pipe_query *query)
335{
336   struct trace_context *tr_ctx = trace_context(_pipe);
337   struct pipe_context *pipe = tr_ctx->pipe;
338
339   trace_dump_call_begin("pipe_context", "end_query");
340
341   trace_dump_arg(ptr, pipe);
342   trace_dump_arg(ptr, query);
343
344   pipe->end_query(pipe, query);
345
346   trace_dump_call_end();
347}
348
349
350static INLINE boolean
351trace_context_get_query_result(struct pipe_context *_pipe,
352                               struct pipe_query *query,
353                               boolean wait,
354                               uint64_t *presult)
355{
356   struct trace_context *tr_ctx = trace_context(_pipe);
357   struct pipe_context *pipe = tr_ctx->pipe;
358   uint64_t result;
359   boolean _result;
360
361   trace_dump_call_begin("pipe_context", "get_query_result");
362
363   trace_dump_arg(ptr, pipe);
364
365   _result = pipe->get_query_result(pipe, query, wait, presult);
366   result = *presult;
367
368   trace_dump_arg(uint, result);
369   trace_dump_ret(bool, _result);
370
371   trace_dump_call_end();
372
373   return _result;
374}
375
376
377static INLINE void *
378trace_context_create_blend_state(struct pipe_context *_pipe,
379                                 const struct pipe_blend_state *state)
380{
381   struct trace_context *tr_ctx = trace_context(_pipe);
382   struct pipe_context *pipe = tr_ctx->pipe;
383   void * result;
384
385   trace_dump_call_begin("pipe_context", "create_blend_state");
386
387   trace_dump_arg(ptr, pipe);
388   trace_dump_arg(blend_state, state);
389
390   result = pipe->create_blend_state(pipe, state);
391
392   trace_dump_ret(ptr, result);
393
394   trace_dump_call_end();
395
396   return result;
397}
398
399
400static INLINE void
401trace_context_bind_blend_state(struct pipe_context *_pipe,
402                               void *state)
403{
404   struct trace_context *tr_ctx = trace_context(_pipe);
405   struct pipe_context *pipe = tr_ctx->pipe;
406
407   trace_dump_call_begin("pipe_context", "bind_blend_state");
408
409   trace_dump_arg(ptr, pipe);
410   trace_dump_arg(ptr, state);
411
412   pipe->bind_blend_state(pipe, state);
413
414   trace_dump_call_end();
415}
416
417
418static INLINE void
419trace_context_delete_blend_state(struct pipe_context *_pipe,
420                                 void *state)
421{
422   struct trace_context *tr_ctx = trace_context(_pipe);
423   struct pipe_context *pipe = tr_ctx->pipe;
424
425   trace_dump_call_begin("pipe_context", "delete_blend_state");
426
427   trace_dump_arg(ptr, pipe);
428   trace_dump_arg(ptr, state);
429
430   pipe->delete_blend_state(pipe, state);
431
432   trace_dump_call_end();
433}
434
435
436static INLINE void *
437trace_context_create_sampler_state(struct pipe_context *_pipe,
438                                   const struct pipe_sampler_state *state)
439{
440   struct trace_context *tr_ctx = trace_context(_pipe);
441   struct pipe_context *pipe = tr_ctx->pipe;
442   void * result;
443
444   trace_dump_call_begin("pipe_context", "create_sampler_state");
445
446   trace_dump_arg(ptr, pipe);
447   trace_dump_arg(sampler_state, state);
448
449   result = pipe->create_sampler_state(pipe, state);
450
451   trace_dump_ret(ptr, result);
452
453   trace_dump_call_end();
454
455   return result;
456}
457
458
459static INLINE void
460trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
461                                           unsigned num_states,
462                                           void **states)
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", "bind_fragment_sampler_states");
468
469   trace_dump_arg(ptr, pipe);
470   trace_dump_arg(uint, num_states);
471   trace_dump_arg_array(ptr, states, num_states);
472
473   pipe->bind_fragment_sampler_states(pipe, num_states, states);
474
475   trace_dump_call_end();
476}
477
478
479static INLINE void
480trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
481                                         unsigned num_states,
482                                         void **states)
483{
484   struct trace_context *tr_ctx = trace_context(_pipe);
485   struct pipe_context *pipe = tr_ctx->pipe;
486
487   trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
488
489   trace_dump_arg(ptr, pipe);
490   trace_dump_arg(uint, num_states);
491   trace_dump_arg_array(ptr, states, num_states);
492
493   pipe->bind_vertex_sampler_states(pipe, num_states, states);
494
495   trace_dump_call_end();
496}
497
498
499static INLINE void
500trace_context_delete_sampler_state(struct pipe_context *_pipe,
501                                   void *state)
502{
503   struct trace_context *tr_ctx = trace_context(_pipe);
504   struct pipe_context *pipe = tr_ctx->pipe;
505
506   trace_dump_call_begin("pipe_context", "delete_sampler_state");
507
508   trace_dump_arg(ptr, pipe);
509   trace_dump_arg(ptr, state);
510
511   pipe->delete_sampler_state(pipe, state);
512
513   trace_dump_call_end();
514}
515
516
517static INLINE void *
518trace_context_create_rasterizer_state(struct pipe_context *_pipe,
519                                      const struct pipe_rasterizer_state *state)
520{
521   struct trace_context *tr_ctx = trace_context(_pipe);
522   struct pipe_context *pipe = tr_ctx->pipe;
523   void * result;
524
525   trace_dump_call_begin("pipe_context", "create_rasterizer_state");
526
527   trace_dump_arg(ptr, pipe);
528   trace_dump_arg(rasterizer_state, state);
529
530   result = pipe->create_rasterizer_state(pipe, state);
531
532   trace_dump_ret(ptr, result);
533
534   trace_dump_call_end();
535
536   return result;
537}
538
539
540static INLINE void
541trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
542                                    void *state)
543{
544   struct trace_context *tr_ctx = trace_context(_pipe);
545   struct pipe_context *pipe = tr_ctx->pipe;
546
547   trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
548
549   trace_dump_arg(ptr, pipe);
550   trace_dump_arg(ptr, state);
551
552   pipe->bind_rasterizer_state(pipe, state);
553
554   trace_dump_call_end();
555}
556
557
558static INLINE void
559trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
560                                      void *state)
561{
562   struct trace_context *tr_ctx = trace_context(_pipe);
563   struct pipe_context *pipe = tr_ctx->pipe;
564
565   trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
566
567   trace_dump_arg(ptr, pipe);
568   trace_dump_arg(ptr, state);
569
570   pipe->delete_rasterizer_state(pipe, state);
571
572   trace_dump_call_end();
573}
574
575
576static INLINE void *
577trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
578                                               const struct pipe_depth_stencil_alpha_state *state)
579{
580   struct trace_context *tr_ctx = trace_context(_pipe);
581   struct pipe_context *pipe = tr_ctx->pipe;
582   void * result;
583
584   trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
585
586   result = pipe->create_depth_stencil_alpha_state(pipe, state);
587
588   trace_dump_arg(ptr, pipe);
589   trace_dump_arg(depth_stencil_alpha_state, state);
590
591   trace_dump_ret(ptr, result);
592
593   trace_dump_call_end();
594
595   return result;
596}
597
598
599static INLINE void
600trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
601                                             void *state)
602{
603   struct trace_context *tr_ctx = trace_context(_pipe);
604   struct pipe_context *pipe = tr_ctx->pipe;
605
606   trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
607
608   trace_dump_arg(ptr, pipe);
609   trace_dump_arg(ptr, state);
610
611   pipe->bind_depth_stencil_alpha_state(pipe, state);
612
613   trace_dump_call_end();
614}
615
616
617static INLINE void
618trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
619                                               void *state)
620{
621   struct trace_context *tr_ctx = trace_context(_pipe);
622   struct pipe_context *pipe = tr_ctx->pipe;
623
624   trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
625
626   trace_dump_arg(ptr, pipe);
627   trace_dump_arg(ptr, state);
628
629   pipe->delete_depth_stencil_alpha_state(pipe, state);
630
631   trace_dump_call_end();
632}
633
634
635static INLINE void *
636trace_context_create_fs_state(struct pipe_context *_pipe,
637                              const struct pipe_shader_state *state)
638{
639   struct trace_context *tr_ctx = trace_context(_pipe);
640   struct pipe_context *pipe = tr_ctx->pipe;
641   void * result;
642
643   trace_dump_call_begin("pipe_context", "create_fs_state");
644
645   trace_dump_arg(ptr, pipe);
646   trace_dump_arg(shader_state, state);
647
648   result = pipe->create_fs_state(pipe, state);
649
650   trace_dump_ret(ptr, result);
651
652   trace_dump_call_end();
653
654   result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT);
655
656   return result;
657}
658
659
660static INLINE void
661trace_context_bind_fs_state(struct pipe_context *_pipe,
662                            void *_state)
663{
664   struct trace_context *tr_ctx = trace_context(_pipe);
665   struct trace_shader *tr_shdr = trace_shader(_state);
666   struct pipe_context *pipe = tr_ctx->pipe;
667   void *state = tr_shdr ? tr_shdr->state : NULL;
668
669   trace_dump_call_begin("pipe_context", "bind_fs_state");
670
671   trace_dump_arg(ptr, pipe);
672   trace_dump_arg(ptr, state);
673
674   tr_ctx->curr.fs = tr_shdr;
675
676   if (tr_shdr && tr_shdr->replaced)
677      state = tr_shdr->replaced;
678
679   pipe->bind_fs_state(pipe, state);
680
681   trace_dump_call_end();
682}
683
684
685static INLINE void
686trace_context_delete_fs_state(struct pipe_context *_pipe,
687                              void *_state)
688{
689   struct trace_context *tr_ctx = trace_context(_pipe);
690   struct trace_shader *tr_shdr = trace_shader(_state);
691   struct pipe_context *pipe = tr_ctx->pipe;
692   void *state = tr_shdr->state;
693
694   trace_dump_call_begin("pipe_context", "delete_fs_state");
695
696   trace_dump_arg(ptr, pipe);
697   trace_dump_arg(ptr, state);
698
699   pipe->delete_fs_state(pipe, state);
700
701   trace_dump_call_end();
702
703   trace_shader_destroy(tr_ctx, tr_shdr);
704}
705
706
707static INLINE void *
708trace_context_create_vs_state(struct pipe_context *_pipe,
709                              const struct pipe_shader_state *state)
710{
711   struct trace_context *tr_ctx = trace_context(_pipe);
712   struct pipe_context *pipe = tr_ctx->pipe;
713   void * result;
714
715   trace_dump_call_begin("pipe_context", "create_vs_state");
716
717   trace_dump_arg(ptr, pipe);
718   trace_dump_arg(shader_state, state);
719
720   result = pipe->create_vs_state(pipe, state);
721
722   trace_dump_ret(ptr, result);
723
724   trace_dump_call_end();
725
726   result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX);
727
728   return result;
729}
730
731
732static INLINE void
733trace_context_bind_vs_state(struct pipe_context *_pipe,
734                            void *_state)
735{
736   struct trace_context *tr_ctx = trace_context(_pipe);
737   struct trace_shader *tr_shdr = trace_shader(_state);
738   struct pipe_context *pipe = tr_ctx->pipe;
739   void *state = tr_shdr ? tr_shdr->state : NULL;
740
741   trace_dump_call_begin("pipe_context", "bind_vs_state");
742
743   trace_dump_arg(ptr, pipe);
744   trace_dump_arg(ptr, state);
745
746   tr_ctx->curr.vs = tr_shdr;
747
748   if (tr_shdr && tr_shdr->replaced)
749      state = tr_shdr->replaced;
750
751   pipe->bind_vs_state(pipe, state);
752
753   trace_dump_call_end();
754}
755
756
757static INLINE void
758trace_context_delete_vs_state(struct pipe_context *_pipe,
759                              void *_state)
760{
761   struct trace_context *tr_ctx = trace_context(_pipe);
762   struct trace_shader *tr_shdr = trace_shader(_state);
763   struct pipe_context *pipe = tr_ctx->pipe;
764   void *state = tr_shdr->state;
765
766   trace_dump_call_begin("pipe_context", "delete_vs_state");
767
768   trace_dump_arg(ptr, pipe);
769   trace_dump_arg(ptr, state);
770
771   pipe->delete_vs_state(pipe, state);
772
773   trace_dump_call_end();
774
775   trace_shader_destroy(tr_ctx, tr_shdr);
776}
777
778
779static INLINE void *
780trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
781                                           unsigned num_elements,
782                                           const struct  pipe_vertex_element *elements)
783{
784   struct trace_context *tr_ctx = trace_context(_pipe);
785   struct pipe_context *pipe = tr_ctx->pipe;
786   void * result;
787
788   trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
789
790   trace_dump_arg(ptr, pipe);
791   trace_dump_arg(uint, num_elements);
792
793   trace_dump_arg_begin("elements");
794   trace_dump_struct_array(vertex_element, elements, num_elements);
795   trace_dump_arg_end();
796
797   result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
798
799   trace_dump_ret(ptr, result);
800
801   trace_dump_call_end();
802
803   return result;
804}
805
806
807static INLINE void
808trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
809                                         void *state)
810{
811   struct trace_context *tr_ctx = trace_context(_pipe);
812   struct pipe_context *pipe = tr_ctx->pipe;
813
814   trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
815
816   trace_dump_arg(ptr, pipe);
817   trace_dump_arg(ptr, state);
818
819   pipe->bind_vertex_elements_state(pipe, state);
820
821   trace_dump_call_end();
822}
823
824
825static INLINE void
826trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
827                                           void *state)
828{
829   struct trace_context *tr_ctx = trace_context(_pipe);
830   struct pipe_context *pipe = tr_ctx->pipe;
831
832   trace_dump_call_begin("pipe_context", "delete_verte_elements_state");
833
834   trace_dump_arg(ptr, pipe);
835   trace_dump_arg(ptr, state);
836
837   pipe->delete_vertex_elements_state(pipe, state);
838
839   trace_dump_call_end();
840}
841
842
843static INLINE void
844trace_context_set_blend_color(struct pipe_context *_pipe,
845                              const struct pipe_blend_color *state)
846{
847   struct trace_context *tr_ctx = trace_context(_pipe);
848   struct pipe_context *pipe = tr_ctx->pipe;
849
850   trace_dump_call_begin("pipe_context", "set_blend_color");
851
852   trace_dump_arg(ptr, pipe);
853   trace_dump_arg(blend_color, state);
854
855   pipe->set_blend_color(pipe, state);
856
857   trace_dump_call_end();
858}
859
860
861static INLINE void
862trace_context_set_stencil_ref(struct pipe_context *_pipe,
863                              const struct pipe_stencil_ref *state)
864{
865   struct trace_context *tr_ctx = trace_context(_pipe);
866   struct pipe_context *pipe = tr_ctx->pipe;
867
868   trace_dump_call_begin("pipe_context", "set_stencil_ref");
869
870   trace_dump_arg(ptr, pipe);
871   trace_dump_arg(stencil_ref, state);
872
873   pipe->set_stencil_ref(pipe, state);
874
875   trace_dump_call_end();
876}
877
878
879static INLINE void
880trace_context_set_clip_state(struct pipe_context *_pipe,
881                             const struct pipe_clip_state *state)
882{
883   struct trace_context *tr_ctx = trace_context(_pipe);
884   struct pipe_context *pipe = tr_ctx->pipe;
885
886   trace_dump_call_begin("pipe_context", "set_clip_state");
887
888   trace_dump_arg(ptr, pipe);
889   trace_dump_arg(clip_state, state);
890
891   pipe->set_clip_state(pipe, state);
892
893   trace_dump_call_end();
894}
895
896
897static INLINE void
898trace_context_set_constant_buffer(struct pipe_context *_pipe,
899                                  uint shader, uint index,
900                                  struct pipe_buffer *buffer)
901{
902   struct trace_context *tr_ctx = trace_context(_pipe);
903   struct pipe_context *pipe = tr_ctx->pipe;
904
905   if (buffer) {
906      trace_screen_user_buffer_update(_pipe->screen, buffer);
907      buffer = trace_buffer_unwrap(tr_ctx, buffer);
908   }
909
910   trace_dump_call_begin("pipe_context", "set_constant_buffer");
911
912   trace_dump_arg(ptr, pipe);
913   trace_dump_arg(uint, shader);
914   trace_dump_arg(uint, index);
915   trace_dump_arg(ptr, buffer);
916
917   pipe->set_constant_buffer(pipe, shader, index, buffer);
918
919   trace_dump_call_end();
920}
921
922
923static INLINE void
924trace_context_set_framebuffer_state(struct pipe_context *_pipe,
925                                    const struct pipe_framebuffer_state *state)
926{
927   struct trace_context *tr_ctx = trace_context(_pipe);
928   struct pipe_context *pipe = tr_ctx->pipe;
929   struct pipe_framebuffer_state unwrapped_state;
930   unsigned i;
931
932   {
933      tr_ctx->curr.nr_cbufs = state->nr_cbufs;
934      for (i = 0; i < state->nr_cbufs; i++)
935         if (state->cbufs[i])
936            tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture);
937         else
938            tr_ctx->curr.cbufs[i] = NULL;
939      if (state->zsbuf)
940         tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture);
941      else
942         tr_ctx->curr.zsbuf = NULL;
943   }
944
945   /* Unwrap the input state */
946   memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
947   for(i = 0; i < state->nr_cbufs; ++i)
948      unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
949   for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
950      unwrapped_state.cbufs[i] = NULL;
951   unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
952   state = &unwrapped_state;
953
954   trace_dump_call_begin("pipe_context", "set_framebuffer_state");
955
956   trace_dump_arg(ptr, pipe);
957   trace_dump_arg(framebuffer_state, state);
958
959   pipe->set_framebuffer_state(pipe, state);
960
961   trace_dump_call_end();
962}
963
964
965static INLINE void
966trace_context_set_polygon_stipple(struct pipe_context *_pipe,
967                                  const struct pipe_poly_stipple *state)
968{
969   struct trace_context *tr_ctx = trace_context(_pipe);
970   struct pipe_context *pipe = tr_ctx->pipe;
971
972   trace_dump_call_begin("pipe_context", "set_polygon_stipple");
973
974   trace_dump_arg(ptr, pipe);
975   trace_dump_arg(poly_stipple, state);
976
977   pipe->set_polygon_stipple(pipe, state);
978
979   trace_dump_call_end();
980}
981
982
983static INLINE void
984trace_context_set_scissor_state(struct pipe_context *_pipe,
985                                const struct pipe_scissor_state *state)
986{
987   struct trace_context *tr_ctx = trace_context(_pipe);
988   struct pipe_context *pipe = tr_ctx->pipe;
989
990   trace_dump_call_begin("pipe_context", "set_scissor_state");
991
992   trace_dump_arg(ptr, pipe);
993   trace_dump_arg(scissor_state, state);
994
995   pipe->set_scissor_state(pipe, state);
996
997   trace_dump_call_end();
998}
999
1000
1001static INLINE void
1002trace_context_set_viewport_state(struct pipe_context *_pipe,
1003                                 const struct pipe_viewport_state *state)
1004{
1005   struct trace_context *tr_ctx = trace_context(_pipe);
1006   struct pipe_context *pipe = tr_ctx->pipe;
1007
1008   trace_dump_call_begin("pipe_context", "set_viewport_state");
1009
1010   trace_dump_arg(ptr, pipe);
1011   trace_dump_arg(viewport_state, state);
1012
1013   pipe->set_viewport_state(pipe, state);
1014
1015   trace_dump_call_end();
1016}
1017
1018
1019static struct pipe_sampler_view *
1020trace_create_sampler_view(struct pipe_context *_pipe,
1021                          struct pipe_texture *_texture,
1022                          const struct pipe_sampler_view *templ)
1023{
1024   struct trace_context *tr_ctx = trace_context(_pipe);
1025   struct trace_texture *tr_tex = trace_texture(_texture);
1026   struct pipe_context *pipe = tr_ctx->pipe;
1027   struct pipe_texture *texture = tr_tex->texture;
1028   struct trace_sampler_view *result = CALLOC_STRUCT(trace_sampler_view);
1029
1030   trace_dump_call_begin("pipe_context", "create_sampler_view");
1031
1032   trace_dump_arg(ptr, pipe);
1033   trace_dump_arg(ptr, texture);
1034   trace_dump_arg(ptr, templ);
1035
1036   result->sampler_view = pipe->create_sampler_view(pipe, texture, templ);
1037
1038   result->base = *templ;
1039   result->base.reference.count = 1;
1040   result->base.texture = NULL;
1041   pipe_texture_reference(&result->base.texture, _texture);
1042   result->base.context = _pipe;
1043
1044   trace_dump_ret(ptr, result);
1045
1046   trace_dump_call_end();
1047
1048   return &result->base;
1049}
1050
1051
1052static void
1053trace_sampler_view_destroy(struct pipe_context *_pipe,
1054                           struct pipe_sampler_view *_view)
1055{
1056   struct trace_context *tr_ctx = trace_context(_pipe);
1057   struct trace_sampler_view *tr_view = trace_sampler_view(_view);
1058   struct pipe_context *pipe = tr_ctx->pipe;
1059   struct pipe_sampler_view *view = tr_view->sampler_view;
1060
1061   trace_dump_call_begin("pipe_context", "sampler_view_destroy");
1062
1063   trace_dump_arg(ptr, pipe);
1064   trace_dump_arg(ptr, view);
1065
1066   pipe->sampler_view_destroy(pipe, view);
1067
1068   trace_dump_call_end();
1069
1070   pipe_texture_reference(&_view->texture, NULL);
1071   FREE(_view);
1072}
1073
1074
1075static INLINE void
1076trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
1077                                         unsigned num,
1078                                         struct pipe_sampler_view **views)
1079{
1080   struct trace_context *tr_ctx = trace_context(_pipe);
1081   struct trace_sampler_view *tr_view;
1082   struct pipe_context *pipe = tr_ctx->pipe;
1083   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
1084   unsigned i;
1085
1086   tr_ctx->curr.num_sampler_views = num;
1087   for(i = 0; i < num; ++i) {
1088      tr_view = trace_sampler_view(views[i]);
1089      tr_ctx->curr.sampler_views[i] = tr_view;
1090      unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1091   }
1092   views = unwrapped_views;
1093
1094   trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
1095
1096   trace_dump_arg(ptr, pipe);
1097   trace_dump_arg(uint, num);
1098   trace_dump_arg_array(ptr, views, num);
1099
1100   pipe->set_fragment_sampler_views(pipe, num, views);
1101
1102   trace_dump_call_end();
1103}
1104
1105
1106static INLINE void
1107trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
1108                                       unsigned num,
1109                                       struct pipe_sampler_view **views)
1110{
1111   struct trace_context *tr_ctx = trace_context(_pipe);
1112   struct trace_sampler_view *tr_view;
1113   struct pipe_context *pipe = tr_ctx->pipe;
1114   struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
1115   unsigned i;
1116
1117   tr_ctx->curr.num_vert_sampler_views = num;
1118   for(i = 0; i < num; ++i) {
1119      tr_view = trace_sampler_view(views[i]);
1120      tr_ctx->curr.vert_sampler_views[i] = tr_view;
1121      unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1122   }
1123   views = unwrapped_views;
1124
1125   trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
1126
1127   trace_dump_arg(ptr, pipe);
1128   trace_dump_arg(uint, num);
1129   trace_dump_arg_array(ptr, views, num);
1130
1131   pipe->set_vertex_sampler_views(pipe, num, views);
1132
1133   trace_dump_call_end();
1134}
1135
1136
1137static INLINE void
1138trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1139                                 unsigned num_buffers,
1140                                 const struct pipe_vertex_buffer *buffers)
1141{
1142   struct trace_context *tr_ctx = trace_context(_pipe);
1143   struct pipe_context *pipe = tr_ctx->pipe;
1144   unsigned i;
1145
1146   for(i = 0; i < num_buffers; ++i)
1147      trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
1148
1149   trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1150
1151   trace_dump_arg(ptr, pipe);
1152   trace_dump_arg(uint, num_buffers);
1153
1154   trace_dump_arg_begin("buffers");
1155   trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1156   trace_dump_arg_end();
1157
1158   if (num_buffers) {
1159      struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
1160      memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1161      for (i = 0; i < num_buffers; i++)
1162         _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
1163      pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1164      free(_buffers);
1165   } else {
1166      pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1167   }
1168
1169   trace_dump_call_end();
1170}
1171
1172
1173static INLINE void
1174trace_context_surface_copy(struct pipe_context *_pipe,
1175                           struct pipe_surface *dest,
1176                           unsigned destx, unsigned desty,
1177                           struct pipe_surface *src,
1178                           unsigned srcx, unsigned srcy,
1179                           unsigned width, unsigned height)
1180{
1181   struct trace_context *tr_ctx = trace_context(_pipe);
1182   struct pipe_context *pipe = tr_ctx->pipe;
1183
1184   dest = trace_surface_unwrap(tr_ctx, dest);
1185   src = trace_surface_unwrap(tr_ctx, src);
1186
1187   trace_dump_call_begin("pipe_context", "surface_copy");
1188
1189   trace_dump_arg(ptr, pipe);
1190   trace_dump_arg(ptr, dest);
1191   trace_dump_arg(uint, destx);
1192   trace_dump_arg(uint, desty);
1193   trace_dump_arg(ptr, src);
1194   trace_dump_arg(uint, srcx);
1195   trace_dump_arg(uint, srcy);
1196   trace_dump_arg(uint, width);
1197   trace_dump_arg(uint, height);
1198
1199   pipe->surface_copy(pipe,
1200                      dest, destx, desty,
1201                      src, srcx, srcy, width, height);
1202
1203   trace_dump_call_end();
1204}
1205
1206
1207static INLINE void
1208trace_context_surface_fill(struct pipe_context *_pipe,
1209                           struct pipe_surface *dst,
1210                           unsigned dstx, unsigned dsty,
1211                           unsigned width, unsigned height,
1212                           unsigned value)
1213{
1214   struct trace_context *tr_ctx = trace_context(_pipe);
1215   struct pipe_context *pipe = tr_ctx->pipe;
1216
1217   dst = trace_surface_unwrap(tr_ctx, dst);
1218
1219   trace_dump_call_begin("pipe_context", "surface_fill");
1220
1221   trace_dump_arg(ptr, pipe);
1222   trace_dump_arg(ptr, dst);
1223   trace_dump_arg(uint, dstx);
1224   trace_dump_arg(uint, dsty);
1225   trace_dump_arg(uint, width);
1226   trace_dump_arg(uint, height);
1227
1228   pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);
1229
1230   trace_dump_call_end();
1231}
1232
1233
1234static INLINE void
1235trace_context_clear(struct pipe_context *_pipe,
1236                    unsigned buffers,
1237                    const float *rgba,
1238                    double depth,
1239                    unsigned stencil)
1240{
1241   struct trace_context *tr_ctx = trace_context(_pipe);
1242   struct pipe_context *pipe = tr_ctx->pipe;
1243
1244   trace_dump_call_begin("pipe_context", "clear");
1245
1246   trace_dump_arg(ptr, pipe);
1247   trace_dump_arg(uint, buffers);
1248   trace_dump_arg_array(float, rgba, 4);
1249   trace_dump_arg(float, depth);
1250   trace_dump_arg(uint, stencil);
1251
1252   pipe->clear(pipe, buffers, rgba, depth, stencil);
1253
1254   trace_dump_call_end();
1255}
1256
1257
1258static INLINE void
1259trace_context_flush(struct pipe_context *_pipe,
1260                    unsigned flags,
1261                    struct pipe_fence_handle **fence)
1262{
1263   struct trace_context *tr_ctx = trace_context(_pipe);
1264   struct pipe_context *pipe = tr_ctx->pipe;
1265
1266   trace_dump_call_begin("pipe_context", "flush");
1267
1268   trace_dump_arg(ptr, pipe);
1269   trace_dump_arg(uint, flags);
1270
1271   pipe->flush(pipe, flags, fence);
1272
1273   if(fence)
1274      trace_dump_ret(ptr, *fence);
1275
1276   trace_dump_call_end();
1277}
1278
1279
1280static INLINE void
1281trace_context_destroy(struct pipe_context *_pipe)
1282{
1283   struct trace_screen *tr_scr = trace_screen(_pipe->screen);
1284   struct trace_context *tr_ctx = trace_context(_pipe);
1285   struct pipe_context *pipe = tr_ctx->pipe;
1286
1287   trace_dump_call_begin("pipe_context", "destroy");
1288   trace_dump_arg(ptr, pipe);
1289   trace_dump_call_end();
1290
1291   trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
1292
1293   pipe->destroy(pipe);
1294
1295   FREE(tr_ctx);
1296}
1297
1298static unsigned int
1299trace_is_texture_referenced( struct pipe_context *_pipe,
1300			    struct pipe_texture *_texture,
1301			    unsigned face, unsigned level)
1302{
1303   struct trace_context *tr_ctx = trace_context(_pipe);
1304   struct trace_texture *tr_tex = trace_texture(_texture);
1305   struct pipe_context *pipe = tr_ctx->pipe;
1306   struct pipe_texture *texture = tr_tex->texture;
1307   unsigned int referenced;
1308
1309   trace_dump_call_begin("pipe_context", "is_texture_referenced");
1310   trace_dump_arg(ptr, pipe);
1311   trace_dump_arg(ptr, texture);
1312   trace_dump_arg(uint, face);
1313   trace_dump_arg(uint, level);
1314
1315   referenced = pipe->is_texture_referenced(pipe, texture, face, level);
1316
1317   trace_dump_ret(uint, referenced);
1318   trace_dump_call_end();
1319
1320   return referenced;
1321}
1322
1323static unsigned int
1324trace_is_buffer_referenced( struct pipe_context *_pipe,
1325			    struct pipe_buffer *_buf)
1326{
1327   struct trace_context *tr_ctx = trace_context(_pipe);
1328   struct trace_buffer *tr_buf = trace_buffer(_buf);
1329   struct pipe_context *pipe = tr_ctx->pipe;
1330   struct pipe_buffer *buf = tr_buf->buffer;
1331   unsigned int referenced;
1332
1333   trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1334   trace_dump_arg(ptr, pipe);
1335   trace_dump_arg(ptr, buf);
1336
1337   referenced = pipe->is_buffer_referenced(pipe, buf);
1338
1339   trace_dump_ret(uint, referenced);
1340   trace_dump_call_end();
1341
1342   return referenced;
1343}
1344
1345
1346/********************************************************************
1347 * transfer
1348 */
1349
1350
1351static struct pipe_transfer *
1352trace_context_get_tex_transfer(struct pipe_context *_context,
1353                              struct pipe_texture *_texture,
1354                              unsigned face, unsigned level,
1355                              unsigned zslice,
1356                              enum pipe_transfer_usage usage,
1357                              unsigned x, unsigned y, unsigned w, unsigned h)
1358{
1359   struct trace_context *tr_context = trace_context(_context);
1360   struct trace_texture *tr_tex = trace_texture(_texture);
1361   struct pipe_context *context = tr_context->pipe;
1362   struct pipe_texture *texture = tr_tex->texture;
1363   struct pipe_transfer *result = NULL;
1364
1365   assert(texture->screen == context->screen);
1366
1367   trace_dump_call_begin("pipe_context", "get_tex_transfer");
1368
1369   trace_dump_arg(ptr, context);
1370   trace_dump_arg(ptr, texture);
1371   trace_dump_arg(uint, face);
1372   trace_dump_arg(uint, level);
1373   trace_dump_arg(uint, zslice);
1374   trace_dump_arg(uint, usage);
1375
1376   trace_dump_arg(uint, x);
1377   trace_dump_arg(uint, y);
1378   trace_dump_arg(uint, w);
1379   trace_dump_arg(uint, h);
1380
1381   result = context->get_tex_transfer(context, texture, face, level, zslice, usage,
1382				      x, y, w, h);
1383
1384   trace_dump_ret(ptr, result);
1385
1386   trace_dump_call_end();
1387
1388   if (result)
1389      result = trace_transfer_create(tr_context, tr_tex, result);
1390
1391   return result;
1392}
1393
1394
1395static void
1396trace_context_tex_transfer_destroy(struct pipe_context *_context,
1397                                   struct pipe_transfer *_transfer)
1398{
1399   struct trace_context *tr_context = trace_context(_context);
1400   struct trace_transfer *tr_trans = trace_transfer(_transfer);
1401   struct pipe_context *context = tr_context->pipe;
1402   struct pipe_transfer *transfer = tr_trans->transfer;
1403
1404   trace_dump_call_begin("pipe_context", "tex_transfer_destroy");
1405
1406   trace_dump_arg(ptr, context);
1407   trace_dump_arg(ptr, transfer);
1408
1409   trace_dump_call_end();
1410
1411   trace_transfer_destroy(tr_context, tr_trans);
1412}
1413
1414
1415static void *
1416trace_context_transfer_map(struct pipe_context *_context,
1417                          struct pipe_transfer *_transfer)
1418{
1419   struct trace_context *tr_context = trace_context(_context);
1420   struct trace_transfer *tr_trans = trace_transfer(_transfer);
1421   struct pipe_context *context = tr_context->pipe;
1422   struct pipe_transfer *transfer = tr_trans->transfer;
1423   void *map;
1424
1425   map = context->transfer_map(context, transfer);
1426   if(map) {
1427      if(transfer->usage & PIPE_TRANSFER_WRITE) {
1428         assert(!tr_trans->map);
1429         tr_trans->map = map;
1430      }
1431   }
1432
1433   return map;
1434}
1435
1436
1437static void
1438trace_context_transfer_unmap(struct pipe_context *_context,
1439			     struct pipe_transfer *_transfer)
1440{
1441   struct trace_context *tr_ctx = trace_context(_context);
1442   struct trace_transfer *tr_trans = trace_transfer(_transfer);
1443   struct pipe_context *context = tr_ctx->pipe;
1444   struct pipe_transfer *transfer = tr_trans->transfer;
1445
1446   if(tr_trans->map) {
1447      size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
1448
1449      trace_dump_call_begin("pipe_context", "transfer_write");
1450
1451      trace_dump_arg(ptr, context);
1452
1453      trace_dump_arg(ptr, transfer);
1454
1455      trace_dump_arg_begin("stride");
1456      trace_dump_uint(transfer->stride);
1457      trace_dump_arg_end();
1458
1459      trace_dump_arg_begin("data");
1460      trace_dump_bytes(tr_trans->map, size);
1461      trace_dump_arg_end();
1462
1463      trace_dump_arg_begin("size");
1464      trace_dump_uint(size);
1465      trace_dump_arg_end();
1466
1467      trace_dump_call_end();
1468
1469      tr_trans->map = NULL;
1470   }
1471
1472   context->transfer_unmap(context, transfer);
1473}
1474
1475static const struct debug_named_value rbug_blocker_flags[] = {
1476   {"before", 1},
1477   {"after", 2},
1478   {NULL, 0},
1479};
1480
1481struct pipe_context *
1482trace_context_create(struct trace_screen *tr_scr,
1483                     struct pipe_context *pipe)
1484{
1485   struct trace_context *tr_ctx;
1486
1487   if(!pipe)
1488      goto error1;
1489
1490   if(!trace_enabled())
1491      goto error1;
1492
1493   tr_ctx = CALLOC_STRUCT(trace_context);
1494   if(!tr_ctx)
1495      goto error1;
1496
1497   tr_ctx->base.winsys = NULL;
1498   tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1499   tr_ctx->base.screen = &tr_scr->base;
1500   tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
1501                                                 rbug_blocker_flags,
1502                                                 0);
1503   pipe_mutex_init(tr_ctx->draw_mutex);
1504   pipe_condvar_init(tr_ctx->draw_cond);
1505   pipe_mutex_init(tr_ctx->list_mutex);
1506   make_empty_list(&tr_ctx->shaders);
1507
1508   tr_ctx->base.destroy = trace_context_destroy;
1509   tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1510   tr_ctx->base.draw_elements = trace_context_draw_elements;
1511   tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1512   tr_ctx->base.create_query = trace_context_create_query;
1513   tr_ctx->base.destroy_query = trace_context_destroy_query;
1514   tr_ctx->base.begin_query = trace_context_begin_query;
1515   tr_ctx->base.end_query = trace_context_end_query;
1516   tr_ctx->base.get_query_result = trace_context_get_query_result;
1517   tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1518   tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1519   tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1520   tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1521   tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1522   tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1523   tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1524   tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1525   tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1526   tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1527   tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1528   tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1529   tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1530   tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1531   tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1532   tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1533   tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1534   tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1535   tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1536   tr_ctx->base.create_vertex_elements_state = trace_context_create_vertex_elements_state;
1537   tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state;
1538   tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state;
1539   tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1540   tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
1541   tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1542   tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1543   tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1544   tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1545   tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1546   tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1547   tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
1548   tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
1549   tr_ctx->base.create_sampler_view = trace_create_sampler_view;
1550   tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy;
1551   tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1552   if (pipe->surface_copy)
1553      tr_ctx->base.surface_copy = trace_context_surface_copy;
1554   if (pipe->surface_fill)
1555      tr_ctx->base.surface_fill = trace_context_surface_fill;
1556   tr_ctx->base.clear = trace_context_clear;
1557   tr_ctx->base.flush = trace_context_flush;
1558   tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
1559   tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
1560
1561   tr_ctx->base.get_tex_transfer = trace_context_get_tex_transfer;
1562   tr_ctx->base.tex_transfer_destroy = trace_context_tex_transfer_destroy;
1563   tr_ctx->base.transfer_map = trace_context_transfer_map;
1564   tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
1565
1566   tr_ctx->pipe = pipe;
1567
1568   trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
1569
1570   return &tr_ctx->base;
1571
1572error1:
1573   return pipe;
1574}
1575