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