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