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