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