1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
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 VMWARE 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/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_defines.h"
37 #include "tr_dump_state.h"
38 #include "tr_public.h"
39 #include "tr_screen.h"
40 #include "tr_texture.h"
41 #include "tr_context.h"
42
43
44 struct trace_query
45 {
46 unsigned type;
47
48 struct pipe_query *query;
49 };
50
51
52 static inline struct trace_query *
trace_query(struct pipe_query * query)53 trace_query(struct pipe_query *query)
54 {
55 return (struct trace_query *)query;
56 }
57
58
59 static inline struct pipe_query *
trace_query_unwrap(struct pipe_query * query)60 trace_query_unwrap(struct pipe_query *query)
61 {
62 if (query) {
63 return trace_query(query)->query;
64 } else {
65 return NULL;
66 }
67 }
68
69
70 static inline struct pipe_resource *
trace_resource_unwrap(struct trace_context * tr_ctx,struct pipe_resource * resource)71 trace_resource_unwrap(struct trace_context *tr_ctx,
72 struct pipe_resource *resource)
73 {
74 struct trace_resource *tr_res;
75
76 if (!resource)
77 return NULL;
78
79 tr_res = trace_resource(resource);
80
81 assert(tr_res->resource);
82 return tr_res->resource;
83 }
84
85
86 static inline struct pipe_surface *
trace_surface_unwrap(struct trace_context * tr_ctx,struct pipe_surface * surface)87 trace_surface_unwrap(struct trace_context *tr_ctx,
88 struct pipe_surface *surface)
89 {
90 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
91 struct trace_surface *tr_surf;
92
93 if (!surface)
94 return NULL;
95
96 assert(surface->texture);
97 if (!surface->texture)
98 return surface;
99
100 tr_surf = trace_surface(surface);
101
102 assert(tr_surf->surface);
103 assert(tr_surf->surface->texture->screen == tr_scr->screen);
104 (void) tr_scr;
105 return tr_surf->surface;
106 }
107
108
109 static void
trace_context_draw_vbo(struct pipe_context * _pipe,const struct pipe_draw_info * info)110 trace_context_draw_vbo(struct pipe_context *_pipe,
111 const struct pipe_draw_info *info)
112 {
113 struct trace_context *tr_ctx = trace_context(_pipe);
114 struct pipe_context *pipe = tr_ctx->pipe;
115
116 trace_dump_call_begin("pipe_context", "draw_vbo");
117
118 trace_dump_arg(ptr, pipe);
119 trace_dump_arg(draw_info, info);
120
121 trace_dump_trace_flush();
122
123 if (info->indirect) {
124 struct pipe_draw_info _info;
125
126 memcpy(&_info, info, sizeof(_info));
127 _info.indirect = trace_resource_unwrap(tr_ctx, _info.indirect);
128 _info.indirect_params = trace_resource_unwrap(tr_ctx,
129 _info.indirect_params);
130 pipe->draw_vbo(pipe, &_info);
131 } else {
132 pipe->draw_vbo(pipe, info);
133 }
134
135 trace_dump_call_end();
136 }
137
138
139 static struct pipe_query *
trace_context_create_query(struct pipe_context * _pipe,unsigned query_type,unsigned index)140 trace_context_create_query(struct pipe_context *_pipe,
141 unsigned query_type,
142 unsigned index)
143 {
144 struct trace_context *tr_ctx = trace_context(_pipe);
145 struct pipe_context *pipe = tr_ctx->pipe;
146 struct pipe_query *query;
147
148 trace_dump_call_begin("pipe_context", "create_query");
149
150 trace_dump_arg(ptr, pipe);
151 trace_dump_arg(query_type, query_type);
152 trace_dump_arg(int, index);
153
154 query = pipe->create_query(pipe, query_type, index);
155
156 trace_dump_ret(ptr, query);
157
158 trace_dump_call_end();
159
160 /* Wrap query object. */
161 if (query) {
162 struct trace_query *tr_query = CALLOC_STRUCT(trace_query);
163 if (tr_query) {
164 tr_query->type = query_type;
165 tr_query->query = query;
166 query = (struct pipe_query *)tr_query;
167 } else {
168 pipe->destroy_query(pipe, query);
169 query = NULL;
170 }
171 }
172
173 return query;
174 }
175
176
177 static void
trace_context_destroy_query(struct pipe_context * _pipe,struct pipe_query * _query)178 trace_context_destroy_query(struct pipe_context *_pipe,
179 struct pipe_query *_query)
180 {
181 struct trace_context *tr_ctx = trace_context(_pipe);
182 struct pipe_context *pipe = tr_ctx->pipe;
183 struct trace_query *tr_query = trace_query(_query);
184 struct pipe_query *query = tr_query->query;
185
186 FREE(tr_query);
187
188 trace_dump_call_begin("pipe_context", "destroy_query");
189
190 trace_dump_arg(ptr, pipe);
191 trace_dump_arg(ptr, query);
192
193 pipe->destroy_query(pipe, query);
194
195 trace_dump_call_end();
196 }
197
198
199 static boolean
trace_context_begin_query(struct pipe_context * _pipe,struct pipe_query * query)200 trace_context_begin_query(struct pipe_context *_pipe,
201 struct pipe_query *query)
202 {
203 struct trace_context *tr_ctx = trace_context(_pipe);
204 struct pipe_context *pipe = tr_ctx->pipe;
205 boolean ret;
206
207 query = trace_query_unwrap(query);
208
209 trace_dump_call_begin("pipe_context", "begin_query");
210
211 trace_dump_arg(ptr, pipe);
212 trace_dump_arg(ptr, query);
213
214 ret = pipe->begin_query(pipe, query);
215
216 trace_dump_call_end();
217 return ret;
218 }
219
220
221 static bool
trace_context_end_query(struct pipe_context * _pipe,struct pipe_query * query)222 trace_context_end_query(struct pipe_context *_pipe,
223 struct pipe_query *query)
224 {
225 struct trace_context *tr_ctx = trace_context(_pipe);
226 struct pipe_context *pipe = tr_ctx->pipe;
227 bool ret;
228
229 query = trace_query_unwrap(query);
230
231 trace_dump_call_begin("pipe_context", "end_query");
232
233 trace_dump_arg(ptr, pipe);
234 trace_dump_arg(ptr, query);
235
236 ret = pipe->end_query(pipe, query);
237
238 trace_dump_call_end();
239 return ret;
240 }
241
242
243 static boolean
trace_context_get_query_result(struct pipe_context * _pipe,struct pipe_query * _query,boolean wait,union pipe_query_result * result)244 trace_context_get_query_result(struct pipe_context *_pipe,
245 struct pipe_query *_query,
246 boolean wait,
247 union pipe_query_result *result)
248 {
249 struct trace_context *tr_ctx = trace_context(_pipe);
250 struct pipe_context *pipe = tr_ctx->pipe;
251 struct trace_query *tr_query = trace_query(_query);
252 struct pipe_query *query = tr_query->query;
253 boolean ret;
254
255 trace_dump_call_begin("pipe_context", "get_query_result");
256
257 trace_dump_arg(ptr, pipe);
258 trace_dump_arg(ptr, query);
259
260 ret = pipe->get_query_result(pipe, query, wait, result);
261
262 trace_dump_arg_begin("result");
263 if (ret) {
264 trace_dump_query_result(tr_query->type, result);
265 } else {
266 trace_dump_null();
267 }
268 trace_dump_arg_end();
269
270 trace_dump_ret(bool, ret);
271
272 trace_dump_call_end();
273
274 return ret;
275 }
276
277
278 static void
trace_context_set_active_query_state(struct pipe_context * _pipe,boolean enable)279 trace_context_set_active_query_state(struct pipe_context *_pipe,
280 boolean enable)
281 {
282 struct trace_context *tr_ctx = trace_context(_pipe);
283 struct pipe_context *pipe = tr_ctx->pipe;
284
285 trace_dump_call_begin("pipe_context", "set_active_query_state");
286
287 trace_dump_arg(ptr, pipe);
288 trace_dump_arg(bool, enable);
289
290 pipe->set_active_query_state(pipe, enable);
291
292 trace_dump_call_end();
293 }
294
295
296 static void *
trace_context_create_blend_state(struct pipe_context * _pipe,const struct pipe_blend_state * state)297 trace_context_create_blend_state(struct pipe_context *_pipe,
298 const struct pipe_blend_state *state)
299 {
300 struct trace_context *tr_ctx = trace_context(_pipe);
301 struct pipe_context *pipe = tr_ctx->pipe;
302 void * result;
303
304 trace_dump_call_begin("pipe_context", "create_blend_state");
305
306 trace_dump_arg(ptr, pipe);
307 trace_dump_arg(blend_state, state);
308
309 result = pipe->create_blend_state(pipe, state);
310
311 trace_dump_ret(ptr, result);
312
313 trace_dump_call_end();
314
315 return result;
316 }
317
318
319 static void
trace_context_bind_blend_state(struct pipe_context * _pipe,void * state)320 trace_context_bind_blend_state(struct pipe_context *_pipe,
321 void *state)
322 {
323 struct trace_context *tr_ctx = trace_context(_pipe);
324 struct pipe_context *pipe = tr_ctx->pipe;
325
326 trace_dump_call_begin("pipe_context", "bind_blend_state");
327
328 trace_dump_arg(ptr, pipe);
329 trace_dump_arg(ptr, state);
330
331 pipe->bind_blend_state(pipe, state);
332
333 trace_dump_call_end();
334 }
335
336
337 static void
trace_context_delete_blend_state(struct pipe_context * _pipe,void * state)338 trace_context_delete_blend_state(struct pipe_context *_pipe,
339 void *state)
340 {
341 struct trace_context *tr_ctx = trace_context(_pipe);
342 struct pipe_context *pipe = tr_ctx->pipe;
343
344 trace_dump_call_begin("pipe_context", "delete_blend_state");
345
346 trace_dump_arg(ptr, pipe);
347 trace_dump_arg(ptr, state);
348
349 pipe->delete_blend_state(pipe, state);
350
351 trace_dump_call_end();
352 }
353
354
355 static void *
trace_context_create_sampler_state(struct pipe_context * _pipe,const struct pipe_sampler_state * state)356 trace_context_create_sampler_state(struct pipe_context *_pipe,
357 const struct pipe_sampler_state *state)
358 {
359 struct trace_context *tr_ctx = trace_context(_pipe);
360 struct pipe_context *pipe = tr_ctx->pipe;
361 void * result;
362
363 trace_dump_call_begin("pipe_context", "create_sampler_state");
364
365 trace_dump_arg(ptr, pipe);
366 trace_dump_arg(sampler_state, state);
367
368 result = pipe->create_sampler_state(pipe, state);
369
370 trace_dump_ret(ptr, result);
371
372 trace_dump_call_end();
373
374 return result;
375 }
376
377
378 static void
trace_context_bind_sampler_states(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num_states,void ** states)379 trace_context_bind_sampler_states(struct pipe_context *_pipe,
380 enum pipe_shader_type shader,
381 unsigned start,
382 unsigned num_states,
383 void **states)
384 {
385 struct trace_context *tr_ctx = trace_context(_pipe);
386 struct pipe_context *pipe = tr_ctx->pipe;
387
388 /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
389 assert(start == 0);
390
391 trace_dump_call_begin("pipe_context", "bind_sampler_states");
392
393 trace_dump_arg(ptr, pipe);
394 trace_dump_arg(uint, shader);
395 trace_dump_arg(uint, start);
396 trace_dump_arg(uint, num_states);
397 trace_dump_arg_array(ptr, states, num_states);
398
399 pipe->bind_sampler_states(pipe, shader, start, num_states, states);
400
401 trace_dump_call_end();
402 }
403
404
405 static void
trace_context_delete_sampler_state(struct pipe_context * _pipe,void * state)406 trace_context_delete_sampler_state(struct pipe_context *_pipe,
407 void *state)
408 {
409 struct trace_context *tr_ctx = trace_context(_pipe);
410 struct pipe_context *pipe = tr_ctx->pipe;
411
412 trace_dump_call_begin("pipe_context", "delete_sampler_state");
413
414 trace_dump_arg(ptr, pipe);
415 trace_dump_arg(ptr, state);
416
417 pipe->delete_sampler_state(pipe, state);
418
419 trace_dump_call_end();
420 }
421
422
423 static void *
trace_context_create_rasterizer_state(struct pipe_context * _pipe,const struct pipe_rasterizer_state * state)424 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
425 const struct pipe_rasterizer_state *state)
426 {
427 struct trace_context *tr_ctx = trace_context(_pipe);
428 struct pipe_context *pipe = tr_ctx->pipe;
429 void * result;
430
431 trace_dump_call_begin("pipe_context", "create_rasterizer_state");
432
433 trace_dump_arg(ptr, pipe);
434 trace_dump_arg(rasterizer_state, state);
435
436 result = pipe->create_rasterizer_state(pipe, state);
437
438 trace_dump_ret(ptr, result);
439
440 trace_dump_call_end();
441
442 return result;
443 }
444
445
446 static void
trace_context_bind_rasterizer_state(struct pipe_context * _pipe,void * state)447 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
448 void *state)
449 {
450 struct trace_context *tr_ctx = trace_context(_pipe);
451 struct pipe_context *pipe = tr_ctx->pipe;
452
453 trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
454
455 trace_dump_arg(ptr, pipe);
456 trace_dump_arg(ptr, state);
457
458 pipe->bind_rasterizer_state(pipe, state);
459
460 trace_dump_call_end();
461 }
462
463
464 static void
trace_context_delete_rasterizer_state(struct pipe_context * _pipe,void * state)465 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
466 void *state)
467 {
468 struct trace_context *tr_ctx = trace_context(_pipe);
469 struct pipe_context *pipe = tr_ctx->pipe;
470
471 trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
472
473 trace_dump_arg(ptr, pipe);
474 trace_dump_arg(ptr, state);
475
476 pipe->delete_rasterizer_state(pipe, state);
477
478 trace_dump_call_end();
479 }
480
481
482 static void *
trace_context_create_depth_stencil_alpha_state(struct pipe_context * _pipe,const struct pipe_depth_stencil_alpha_state * state)483 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
484 const struct pipe_depth_stencil_alpha_state *state)
485 {
486 struct trace_context *tr_ctx = trace_context(_pipe);
487 struct pipe_context *pipe = tr_ctx->pipe;
488 void * result;
489
490 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
491
492 result = pipe->create_depth_stencil_alpha_state(pipe, state);
493
494 trace_dump_arg(ptr, pipe);
495 trace_dump_arg(depth_stencil_alpha_state, state);
496
497 trace_dump_ret(ptr, result);
498
499 trace_dump_call_end();
500
501 return result;
502 }
503
504
505 static void
trace_context_bind_depth_stencil_alpha_state(struct pipe_context * _pipe,void * state)506 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
507 void *state)
508 {
509 struct trace_context *tr_ctx = trace_context(_pipe);
510 struct pipe_context *pipe = tr_ctx->pipe;
511
512 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
513
514 trace_dump_arg(ptr, pipe);
515 trace_dump_arg(ptr, state);
516
517 pipe->bind_depth_stencil_alpha_state(pipe, state);
518
519 trace_dump_call_end();
520 }
521
522
523 static void
trace_context_delete_depth_stencil_alpha_state(struct pipe_context * _pipe,void * state)524 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
525 void *state)
526 {
527 struct trace_context *tr_ctx = trace_context(_pipe);
528 struct pipe_context *pipe = tr_ctx->pipe;
529
530 trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
531
532 trace_dump_arg(ptr, pipe);
533 trace_dump_arg(ptr, state);
534
535 pipe->delete_depth_stencil_alpha_state(pipe, state);
536
537 trace_dump_call_end();
538 }
539
540
541 #define TRACE_SHADER_STATE(shader_type) \
542 static void * \
543 trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \
544 const struct pipe_shader_state *state) \
545 { \
546 struct trace_context *tr_ctx = trace_context(_pipe); \
547 struct pipe_context *pipe = tr_ctx->pipe; \
548 void * result; \
549 trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \
550 trace_dump_arg(ptr, pipe); \
551 trace_dump_arg(shader_state, state); \
552 result = pipe->create_##shader_type##_state(pipe, state); \
553 trace_dump_ret(ptr, result); \
554 trace_dump_call_end(); \
555 return result; \
556 } \
557 \
558 static void \
559 trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \
560 void *state) \
561 { \
562 struct trace_context *tr_ctx = trace_context(_pipe); \
563 struct pipe_context *pipe = tr_ctx->pipe; \
564 trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \
565 trace_dump_arg(ptr, pipe); \
566 trace_dump_arg(ptr, state); \
567 pipe->bind_##shader_type##_state(pipe, state); \
568 trace_dump_call_end(); \
569 } \
570 \
571 static void \
572 trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \
573 void *state) \
574 { \
575 struct trace_context *tr_ctx = trace_context(_pipe); \
576 struct pipe_context *pipe = tr_ctx->pipe; \
577 trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \
578 trace_dump_arg(ptr, pipe); \
579 trace_dump_arg(ptr, state); \
580 pipe->delete_##shader_type##_state(pipe, state); \
581 trace_dump_call_end(); \
582 }
583
584 TRACE_SHADER_STATE(fs)
TRACE_SHADER_STATE(vs)585 TRACE_SHADER_STATE(vs)
586 TRACE_SHADER_STATE(gs)
587 TRACE_SHADER_STATE(tcs)
588 TRACE_SHADER_STATE(tes)
589
590 #undef TRACE_SHADER_STATE
591
592
593 static inline void *
594 trace_context_create_compute_state(struct pipe_context *_pipe,
595 const struct pipe_compute_state *state)
596 {
597 struct trace_context *tr_ctx = trace_context(_pipe);
598 struct pipe_context *pipe = tr_ctx->pipe;
599 void * result;
600
601 trace_dump_call_begin("pipe_context", "create_compute_state");
602 trace_dump_arg(ptr, pipe);
603 trace_dump_arg(compute_state, state);
604 result = pipe->create_compute_state(pipe, state);
605 trace_dump_ret(ptr, result);
606 trace_dump_call_end();
607 return result;
608 }
609
610 static inline void
trace_context_bind_compute_state(struct pipe_context * _pipe,void * state)611 trace_context_bind_compute_state(struct pipe_context *_pipe,
612 void *state)
613 {
614 struct trace_context *tr_ctx = trace_context(_pipe);
615 struct pipe_context *pipe = tr_ctx->pipe;
616
617 trace_dump_call_begin("pipe_context", "bind_compute_state");
618 trace_dump_arg(ptr, pipe);
619 trace_dump_arg(ptr, state);
620 pipe->bind_compute_state(pipe, state);
621 trace_dump_call_end();
622 }
623
624 static inline void
trace_context_delete_compute_state(struct pipe_context * _pipe,void * state)625 trace_context_delete_compute_state(struct pipe_context *_pipe,
626 void *state)
627 {
628 struct trace_context *tr_ctx = trace_context(_pipe);
629 struct pipe_context *pipe = tr_ctx->pipe;
630
631 trace_dump_call_begin("pipe_context", "delete_compute_state");
632 trace_dump_arg(ptr, pipe);
633 trace_dump_arg(ptr, state);
634 pipe->delete_compute_state(pipe, state);
635 trace_dump_call_end();
636 }
637
638 static void *
trace_context_create_vertex_elements_state(struct pipe_context * _pipe,unsigned num_elements,const struct pipe_vertex_element * elements)639 trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
640 unsigned num_elements,
641 const struct pipe_vertex_element *elements)
642 {
643 struct trace_context *tr_ctx = trace_context(_pipe);
644 struct pipe_context *pipe = tr_ctx->pipe;
645 void * result;
646
647 trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
648
649 trace_dump_arg(ptr, pipe);
650 trace_dump_arg(uint, num_elements);
651
652 trace_dump_arg_begin("elements");
653 trace_dump_struct_array(vertex_element, elements, num_elements);
654 trace_dump_arg_end();
655
656 result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
657
658 trace_dump_ret(ptr, result);
659
660 trace_dump_call_end();
661
662 return result;
663 }
664
665
666 static void
trace_context_bind_vertex_elements_state(struct pipe_context * _pipe,void * state)667 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
668 void *state)
669 {
670 struct trace_context *tr_ctx = trace_context(_pipe);
671 struct pipe_context *pipe = tr_ctx->pipe;
672
673 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
674
675 trace_dump_arg(ptr, pipe);
676 trace_dump_arg(ptr, state);
677
678 pipe->bind_vertex_elements_state(pipe, state);
679
680 trace_dump_call_end();
681 }
682
683
684 static void
trace_context_delete_vertex_elements_state(struct pipe_context * _pipe,void * state)685 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
686 void *state)
687 {
688 struct trace_context *tr_ctx = trace_context(_pipe);
689 struct pipe_context *pipe = tr_ctx->pipe;
690
691 trace_dump_call_begin("pipe_context", "delete_vertex_elements_state");
692
693 trace_dump_arg(ptr, pipe);
694 trace_dump_arg(ptr, state);
695
696 pipe->delete_vertex_elements_state(pipe, state);
697
698 trace_dump_call_end();
699 }
700
701
702 static void
trace_context_set_blend_color(struct pipe_context * _pipe,const struct pipe_blend_color * state)703 trace_context_set_blend_color(struct pipe_context *_pipe,
704 const struct pipe_blend_color *state)
705 {
706 struct trace_context *tr_ctx = trace_context(_pipe);
707 struct pipe_context *pipe = tr_ctx->pipe;
708
709 trace_dump_call_begin("pipe_context", "set_blend_color");
710
711 trace_dump_arg(ptr, pipe);
712 trace_dump_arg(blend_color, state);
713
714 pipe->set_blend_color(pipe, state);
715
716 trace_dump_call_end();
717 }
718
719
720 static void
trace_context_set_stencil_ref(struct pipe_context * _pipe,const struct pipe_stencil_ref * state)721 trace_context_set_stencil_ref(struct pipe_context *_pipe,
722 const struct pipe_stencil_ref *state)
723 {
724 struct trace_context *tr_ctx = trace_context(_pipe);
725 struct pipe_context *pipe = tr_ctx->pipe;
726
727 trace_dump_call_begin("pipe_context", "set_stencil_ref");
728
729 trace_dump_arg(ptr, pipe);
730 trace_dump_arg(stencil_ref, state);
731
732 pipe->set_stencil_ref(pipe, state);
733
734 trace_dump_call_end();
735 }
736
737
738 static void
trace_context_set_clip_state(struct pipe_context * _pipe,const struct pipe_clip_state * state)739 trace_context_set_clip_state(struct pipe_context *_pipe,
740 const struct pipe_clip_state *state)
741 {
742 struct trace_context *tr_ctx = trace_context(_pipe);
743 struct pipe_context *pipe = tr_ctx->pipe;
744
745 trace_dump_call_begin("pipe_context", "set_clip_state");
746
747 trace_dump_arg(ptr, pipe);
748 trace_dump_arg(clip_state, state);
749
750 pipe->set_clip_state(pipe, state);
751
752 trace_dump_call_end();
753 }
754
755 static void
trace_context_set_sample_mask(struct pipe_context * _pipe,unsigned sample_mask)756 trace_context_set_sample_mask(struct pipe_context *_pipe,
757 unsigned sample_mask)
758 {
759 struct trace_context *tr_ctx = trace_context(_pipe);
760 struct pipe_context *pipe = tr_ctx->pipe;
761
762 trace_dump_call_begin("pipe_context", "set_sample_mask");
763
764 trace_dump_arg(ptr, pipe);
765 trace_dump_arg(uint, sample_mask);
766
767 pipe->set_sample_mask(pipe, sample_mask);
768
769 trace_dump_call_end();
770 }
771
772 static void
trace_context_set_constant_buffer(struct pipe_context * _pipe,uint shader,uint index,const struct pipe_constant_buffer * constant_buffer)773 trace_context_set_constant_buffer(struct pipe_context *_pipe,
774 uint shader, uint index,
775 const struct pipe_constant_buffer *constant_buffer)
776 {
777 struct trace_context *tr_ctx = trace_context(_pipe);
778 struct pipe_context *pipe = tr_ctx->pipe;
779 struct pipe_constant_buffer cb;
780
781 if (constant_buffer) {
782 cb = *constant_buffer;
783 cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer);
784 constant_buffer = &cb;
785 }
786
787 trace_dump_call_begin("pipe_context", "set_constant_buffer");
788
789 trace_dump_arg(ptr, pipe);
790 trace_dump_arg(uint, shader);
791 trace_dump_arg(uint, index);
792 trace_dump_arg(constant_buffer, constant_buffer);
793
794 pipe->set_constant_buffer(pipe, shader, index, constant_buffer);
795
796 trace_dump_call_end();
797 }
798
799
800 static void
trace_context_set_framebuffer_state(struct pipe_context * _pipe,const struct pipe_framebuffer_state * state)801 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
802 const struct pipe_framebuffer_state *state)
803 {
804 struct trace_context *tr_ctx = trace_context(_pipe);
805 struct pipe_context *pipe = tr_ctx->pipe;
806 struct pipe_framebuffer_state unwrapped_state;
807 unsigned i;
808
809
810 /* Unwrap the input state */
811 memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
812 for (i = 0; i < state->nr_cbufs; ++i)
813 unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
814 for (i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
815 unwrapped_state.cbufs[i] = NULL;
816 unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
817 state = &unwrapped_state;
818
819 trace_dump_call_begin("pipe_context", "set_framebuffer_state");
820
821 trace_dump_arg(ptr, pipe);
822 trace_dump_arg(framebuffer_state, state);
823
824 pipe->set_framebuffer_state(pipe, state);
825
826 trace_dump_call_end();
827 }
828
829
830 static void
trace_context_set_polygon_stipple(struct pipe_context * _pipe,const struct pipe_poly_stipple * state)831 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
832 const struct pipe_poly_stipple *state)
833 {
834 struct trace_context *tr_ctx = trace_context(_pipe);
835 struct pipe_context *pipe = tr_ctx->pipe;
836
837 trace_dump_call_begin("pipe_context", "set_polygon_stipple");
838
839 trace_dump_arg(ptr, pipe);
840 trace_dump_arg(poly_stipple, state);
841
842 pipe->set_polygon_stipple(pipe, state);
843
844 trace_dump_call_end();
845 }
846
847
848 static void
trace_context_set_scissor_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_scissors,const struct pipe_scissor_state * states)849 trace_context_set_scissor_states(struct pipe_context *_pipe,
850 unsigned start_slot,
851 unsigned num_scissors,
852 const struct pipe_scissor_state *states)
853 {
854 struct trace_context *tr_ctx = trace_context(_pipe);
855 struct pipe_context *pipe = tr_ctx->pipe;
856
857 trace_dump_call_begin("pipe_context", "set_scissor_states");
858
859 trace_dump_arg(ptr, pipe);
860 trace_dump_arg(uint, start_slot);
861 trace_dump_arg(uint, num_scissors);
862 trace_dump_arg(scissor_state, states);
863
864 pipe->set_scissor_states(pipe, start_slot, num_scissors, states);
865
866 trace_dump_call_end();
867 }
868
869
870 static void
trace_context_set_viewport_states(struct pipe_context * _pipe,unsigned start_slot,unsigned num_viewports,const struct pipe_viewport_state * states)871 trace_context_set_viewport_states(struct pipe_context *_pipe,
872 unsigned start_slot,
873 unsigned num_viewports,
874 const struct pipe_viewport_state *states)
875 {
876 struct trace_context *tr_ctx = trace_context(_pipe);
877 struct pipe_context *pipe = tr_ctx->pipe;
878
879 trace_dump_call_begin("pipe_context", "set_viewport_states");
880
881 trace_dump_arg(ptr, pipe);
882 trace_dump_arg(uint, start_slot);
883 trace_dump_arg(uint, num_viewports);
884 trace_dump_arg(viewport_state, states);
885
886 pipe->set_viewport_states(pipe, start_slot, num_viewports, states);
887
888 trace_dump_call_end();
889 }
890
891
892 static struct pipe_sampler_view *
trace_context_create_sampler_view(struct pipe_context * _pipe,struct pipe_resource * _resource,const struct pipe_sampler_view * templ)893 trace_context_create_sampler_view(struct pipe_context *_pipe,
894 struct pipe_resource *_resource,
895 const struct pipe_sampler_view *templ)
896 {
897 struct trace_context *tr_ctx = trace_context(_pipe);
898 struct trace_resource *tr_res = trace_resource(_resource);
899 struct pipe_context *pipe = tr_ctx->pipe;
900 struct pipe_resource *resource = tr_res->resource;
901 struct pipe_sampler_view *result;
902 struct trace_sampler_view *tr_view;
903
904 trace_dump_call_begin("pipe_context", "create_sampler_view");
905
906 trace_dump_arg(ptr, pipe);
907 trace_dump_arg(ptr, resource);
908
909 trace_dump_arg_begin("templ");
910 trace_dump_sampler_view_template(templ, resource->target);
911 trace_dump_arg_end();
912
913 result = pipe->create_sampler_view(pipe, resource, templ);
914
915 trace_dump_ret(ptr, result);
916
917 trace_dump_call_end();
918
919 /*
920 * Wrap pipe_sampler_view
921 */
922 tr_view = CALLOC_STRUCT(trace_sampler_view);
923 tr_view->base = *templ;
924 tr_view->base.reference.count = 1;
925 tr_view->base.texture = NULL;
926 pipe_resource_reference(&tr_view->base.texture, _resource);
927 tr_view->base.context = _pipe;
928 tr_view->sampler_view = result;
929 result = &tr_view->base;
930
931 return result;
932 }
933
934
935 static void
trace_context_sampler_view_destroy(struct pipe_context * _pipe,struct pipe_sampler_view * _view)936 trace_context_sampler_view_destroy(struct pipe_context *_pipe,
937 struct pipe_sampler_view *_view)
938 {
939 struct trace_context *tr_ctx = trace_context(_pipe);
940 struct trace_sampler_view *tr_view = trace_sampler_view(_view);
941 struct pipe_context *pipe = tr_ctx->pipe;
942 struct pipe_sampler_view *view = tr_view->sampler_view;
943
944 assert(_view->context == _pipe);
945
946 trace_dump_call_begin("pipe_context", "sampler_view_destroy");
947
948 trace_dump_arg(ptr, pipe);
949 trace_dump_arg(ptr, view);
950
951 pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
952
953 trace_dump_call_end();
954
955 pipe_resource_reference(&_view->texture, NULL);
956 FREE(_view);
957 }
958
959 /********************************************************************
960 * surface
961 */
962
963
964 static struct pipe_surface *
trace_context_create_surface(struct pipe_context * _pipe,struct pipe_resource * _resource,const struct pipe_surface * surf_tmpl)965 trace_context_create_surface(struct pipe_context *_pipe,
966 struct pipe_resource *_resource,
967 const struct pipe_surface *surf_tmpl)
968 {
969 struct trace_context *tr_ctx = trace_context(_pipe);
970 struct trace_resource *tr_res = trace_resource(_resource);
971 struct pipe_context *pipe = tr_ctx->pipe;
972 struct pipe_resource *resource = tr_res->resource;
973 struct pipe_surface *result = NULL;
974
975 trace_dump_call_begin("pipe_context", "create_surface");
976
977 trace_dump_arg(ptr, pipe);
978 trace_dump_arg(ptr, resource);
979
980 trace_dump_arg_begin("surf_tmpl");
981 trace_dump_surface_template(surf_tmpl, resource->target);
982 trace_dump_arg_end();
983
984
985 result = pipe->create_surface(pipe, resource, surf_tmpl);
986
987 trace_dump_ret(ptr, result);
988
989 trace_dump_call_end();
990
991 result = trace_surf_create(tr_ctx, tr_res, result);
992
993 return result;
994 }
995
996
997 static void
trace_context_surface_destroy(struct pipe_context * _pipe,struct pipe_surface * _surface)998 trace_context_surface_destroy(struct pipe_context *_pipe,
999 struct pipe_surface *_surface)
1000 {
1001 struct trace_context *tr_ctx = trace_context(_pipe);
1002 struct pipe_context *pipe = tr_ctx->pipe;
1003 struct trace_surface *tr_surf = trace_surface(_surface);
1004 struct pipe_surface *surface = tr_surf->surface;
1005
1006 trace_dump_call_begin("pipe_context", "surface_destroy");
1007
1008 trace_dump_arg(ptr, pipe);
1009 trace_dump_arg(ptr, surface);
1010
1011 trace_dump_call_end();
1012
1013 trace_surf_destroy(tr_surf);
1014 }
1015
1016
1017 static void
trace_context_set_sampler_views(struct pipe_context * _pipe,enum pipe_shader_type shader,unsigned start,unsigned num,struct pipe_sampler_view ** views)1018 trace_context_set_sampler_views(struct pipe_context *_pipe,
1019 enum pipe_shader_type shader,
1020 unsigned start,
1021 unsigned num,
1022 struct pipe_sampler_view **views)
1023 {
1024 struct trace_context *tr_ctx = trace_context(_pipe);
1025 struct trace_sampler_view *tr_view;
1026 struct pipe_context *pipe = tr_ctx->pipe;
1027 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS];
1028 unsigned i;
1029
1030 /* remove this when we have pipe->set_sampler_views(..., start, ...) */
1031 assert(start == 0);
1032
1033 for (i = 0; i < num; ++i) {
1034 tr_view = trace_sampler_view(views[i]);
1035 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1036 }
1037 views = unwrapped_views;
1038
1039 trace_dump_call_begin("pipe_context", "set_sampler_views");
1040
1041 trace_dump_arg(ptr, pipe);
1042 trace_dump_arg(uint, shader);
1043 trace_dump_arg(uint, start);
1044 trace_dump_arg(uint, num);
1045 trace_dump_arg_array(ptr, views, num);
1046
1047 pipe->set_sampler_views(pipe, shader, start, num, views);
1048
1049 trace_dump_call_end();
1050 }
1051
1052
1053 static void
trace_context_set_vertex_buffers(struct pipe_context * _pipe,unsigned start_slot,unsigned num_buffers,const struct pipe_vertex_buffer * buffers)1054 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1055 unsigned start_slot, unsigned num_buffers,
1056 const struct pipe_vertex_buffer *buffers)
1057 {
1058 struct trace_context *tr_ctx = trace_context(_pipe);
1059 struct pipe_context *pipe = tr_ctx->pipe;
1060 unsigned i;
1061
1062 trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1063
1064 trace_dump_arg(ptr, pipe);
1065 trace_dump_arg(uint, start_slot);
1066 trace_dump_arg(uint, num_buffers);
1067
1068 trace_dump_arg_begin("buffers");
1069 trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1070 trace_dump_arg_end();
1071
1072 if (buffers) {
1073 struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
1074 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1075 for (i = 0; i < num_buffers; i++)
1076 _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
1077 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers);
1078 FREE(_buffers);
1079 } else {
1080 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL);
1081 }
1082
1083 trace_dump_call_end();
1084 }
1085
1086
1087 static void
trace_context_set_index_buffer(struct pipe_context * _pipe,const struct pipe_index_buffer * ib)1088 trace_context_set_index_buffer(struct pipe_context *_pipe,
1089 const struct pipe_index_buffer *ib)
1090 {
1091 struct trace_context *tr_ctx = trace_context(_pipe);
1092 struct pipe_context *pipe = tr_ctx->pipe;
1093
1094 trace_dump_call_begin("pipe_context", "set_index_buffer");
1095
1096 trace_dump_arg(ptr, pipe);
1097 trace_dump_arg(index_buffer, ib);
1098
1099 if (ib) {
1100 struct pipe_index_buffer _ib;
1101 _ib = *ib;
1102 _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer);
1103 pipe->set_index_buffer(pipe, &_ib);
1104 } else {
1105 pipe->set_index_buffer(pipe, NULL);
1106 }
1107
1108 trace_dump_call_end();
1109 }
1110
1111
1112 static struct pipe_stream_output_target *
trace_context_create_stream_output_target(struct pipe_context * _pipe,struct pipe_resource * res,unsigned buffer_offset,unsigned buffer_size)1113 trace_context_create_stream_output_target(struct pipe_context *_pipe,
1114 struct pipe_resource *res,
1115 unsigned buffer_offset,
1116 unsigned buffer_size)
1117 {
1118 struct trace_context *tr_ctx = trace_context(_pipe);
1119 struct pipe_context *pipe = tr_ctx->pipe;
1120 struct pipe_stream_output_target *result;
1121
1122 res = trace_resource_unwrap(tr_ctx, res);
1123
1124 trace_dump_call_begin("pipe_context", "create_stream_output_target");
1125
1126 trace_dump_arg(ptr, pipe);
1127 trace_dump_arg(ptr, res);
1128 trace_dump_arg(uint, buffer_offset);
1129 trace_dump_arg(uint, buffer_size);
1130
1131 result = pipe->create_stream_output_target(pipe,
1132 res, buffer_offset, buffer_size);
1133
1134 trace_dump_ret(ptr, result);
1135
1136 trace_dump_call_end();
1137
1138 return result;
1139 }
1140
1141
1142 static void
trace_context_stream_output_target_destroy(struct pipe_context * _pipe,struct pipe_stream_output_target * target)1143 trace_context_stream_output_target_destroy(
1144 struct pipe_context *_pipe,
1145 struct pipe_stream_output_target *target)
1146 {
1147 struct trace_context *tr_ctx = trace_context(_pipe);
1148 struct pipe_context *pipe = tr_ctx->pipe;
1149
1150 trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1151
1152 trace_dump_arg(ptr, pipe);
1153 trace_dump_arg(ptr, target);
1154
1155 pipe->stream_output_target_destroy(pipe, target);
1156
1157 trace_dump_call_end();
1158 }
1159
1160
1161 static void
trace_context_set_stream_output_targets(struct pipe_context * _pipe,unsigned num_targets,struct pipe_stream_output_target ** tgs,const unsigned * offsets)1162 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1163 unsigned num_targets,
1164 struct pipe_stream_output_target **tgs,
1165 const unsigned *offsets)
1166 {
1167 struct trace_context *tr_ctx = trace_context(_pipe);
1168 struct pipe_context *pipe = tr_ctx->pipe;
1169
1170 trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1171
1172 trace_dump_arg(ptr, pipe);
1173 trace_dump_arg(uint, num_targets);
1174 trace_dump_arg_array(ptr, tgs, num_targets);
1175 trace_dump_arg_array(uint, offsets, num_targets);
1176
1177 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
1178
1179 trace_dump_call_end();
1180 }
1181
1182
1183 static void
trace_context_resource_copy_region(struct pipe_context * _pipe,struct pipe_resource * dst,unsigned dst_level,unsigned dstx,unsigned dsty,unsigned dstz,struct pipe_resource * src,unsigned src_level,const struct pipe_box * src_box)1184 trace_context_resource_copy_region(struct pipe_context *_pipe,
1185 struct pipe_resource *dst,
1186 unsigned dst_level,
1187 unsigned dstx, unsigned dsty, unsigned dstz,
1188 struct pipe_resource *src,
1189 unsigned src_level,
1190 const struct pipe_box *src_box)
1191 {
1192 struct trace_context *tr_ctx = trace_context(_pipe);
1193 struct pipe_context *pipe = tr_ctx->pipe;
1194
1195 dst = trace_resource_unwrap(tr_ctx, dst);
1196 src = trace_resource_unwrap(tr_ctx, src);
1197
1198 trace_dump_call_begin("pipe_context", "resource_copy_region");
1199
1200 trace_dump_arg(ptr, pipe);
1201 trace_dump_arg(ptr, dst);
1202 trace_dump_arg(uint, dst_level);
1203 trace_dump_arg(uint, dstx);
1204 trace_dump_arg(uint, dsty);
1205 trace_dump_arg(uint, dstz);
1206 trace_dump_arg(ptr, src);
1207 trace_dump_arg(uint, src_level);
1208 trace_dump_arg(box, src_box);
1209
1210 pipe->resource_copy_region(pipe,
1211 dst, dst_level, dstx, dsty, dstz,
1212 src, src_level, src_box);
1213
1214 trace_dump_call_end();
1215 }
1216
1217
1218 static void
trace_context_blit(struct pipe_context * _pipe,const struct pipe_blit_info * _info)1219 trace_context_blit(struct pipe_context *_pipe,
1220 const struct pipe_blit_info *_info)
1221 {
1222 struct trace_context *tr_ctx = trace_context(_pipe);
1223 struct pipe_context *pipe = tr_ctx->pipe;
1224 struct pipe_blit_info info = *_info;
1225
1226 info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
1227 info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
1228
1229 trace_dump_call_begin("pipe_context", "blit");
1230
1231 trace_dump_arg(ptr, pipe);
1232 trace_dump_arg(blit_info, _info);
1233
1234 pipe->blit(pipe, &info);
1235
1236 trace_dump_call_end();
1237 }
1238
1239
1240 static void
trace_context_flush_resource(struct pipe_context * _pipe,struct pipe_resource * resource)1241 trace_context_flush_resource(struct pipe_context *_pipe,
1242 struct pipe_resource *resource)
1243 {
1244 struct trace_context *tr_ctx = trace_context(_pipe);
1245 struct pipe_context *pipe = tr_ctx->pipe;
1246
1247 resource = trace_resource_unwrap(tr_ctx, resource);
1248
1249 trace_dump_call_begin("pipe_context", "flush_resource");
1250
1251 trace_dump_arg(ptr, pipe);
1252 trace_dump_arg(ptr, resource);
1253
1254 pipe->flush_resource(pipe, resource);
1255
1256 trace_dump_call_end();
1257 }
1258
1259
1260 static void
trace_context_clear(struct pipe_context * _pipe,unsigned buffers,const union pipe_color_union * color,double depth,unsigned stencil)1261 trace_context_clear(struct pipe_context *_pipe,
1262 unsigned buffers,
1263 const union pipe_color_union *color,
1264 double depth,
1265 unsigned stencil)
1266 {
1267 struct trace_context *tr_ctx = trace_context(_pipe);
1268 struct pipe_context *pipe = tr_ctx->pipe;
1269
1270 trace_dump_call_begin("pipe_context", "clear");
1271
1272 trace_dump_arg(ptr, pipe);
1273 trace_dump_arg(uint, buffers);
1274 trace_dump_arg_begin("color");
1275 if (color)
1276 trace_dump_array(float, color->f, 4);
1277 else
1278 trace_dump_null();
1279 trace_dump_arg_end();
1280 trace_dump_arg(float, depth);
1281 trace_dump_arg(uint, stencil);
1282
1283 pipe->clear(pipe, buffers, color, depth, stencil);
1284
1285 trace_dump_call_end();
1286 }
1287
1288
1289 static void
trace_context_clear_render_target(struct pipe_context * _pipe,struct pipe_surface * dst,const union pipe_color_union * color,unsigned dstx,unsigned dsty,unsigned width,unsigned height,bool render_condition_enabled)1290 trace_context_clear_render_target(struct pipe_context *_pipe,
1291 struct pipe_surface *dst,
1292 const union pipe_color_union *color,
1293 unsigned dstx, unsigned dsty,
1294 unsigned width, unsigned height,
1295 bool render_condition_enabled)
1296 {
1297 struct trace_context *tr_ctx = trace_context(_pipe);
1298 struct pipe_context *pipe = tr_ctx->pipe;
1299
1300 dst = trace_surface_unwrap(tr_ctx, dst);
1301
1302 trace_dump_call_begin("pipe_context", "clear_render_target");
1303
1304 trace_dump_arg(ptr, pipe);
1305 trace_dump_arg(ptr, dst);
1306 trace_dump_arg_array(float, color->f, 4);
1307 trace_dump_arg(uint, dstx);
1308 trace_dump_arg(uint, dsty);
1309 trace_dump_arg(uint, width);
1310 trace_dump_arg(uint, height);
1311 trace_dump_arg(bool, render_condition_enabled);
1312
1313 pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height,
1314 render_condition_enabled);
1315
1316 trace_dump_call_end();
1317 }
1318
1319 static void
trace_context_clear_depth_stencil(struct pipe_context * _pipe,struct pipe_surface * dst,unsigned clear_flags,double depth,unsigned stencil,unsigned dstx,unsigned dsty,unsigned width,unsigned height,bool render_condition_enabled)1320 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1321 struct pipe_surface *dst,
1322 unsigned clear_flags,
1323 double depth,
1324 unsigned stencil,
1325 unsigned dstx, unsigned dsty,
1326 unsigned width, unsigned height,
1327 bool render_condition_enabled)
1328 {
1329 struct trace_context *tr_ctx = trace_context(_pipe);
1330 struct pipe_context *pipe = tr_ctx->pipe;
1331
1332 dst = trace_surface_unwrap(tr_ctx, dst);
1333
1334 trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1335
1336 trace_dump_arg(ptr, pipe);
1337 trace_dump_arg(ptr, dst);
1338 trace_dump_arg(uint, clear_flags);
1339 trace_dump_arg(float, depth);
1340 trace_dump_arg(uint, stencil);
1341 trace_dump_arg(uint, dstx);
1342 trace_dump_arg(uint, dsty);
1343 trace_dump_arg(uint, width);
1344 trace_dump_arg(uint, height);
1345 trace_dump_arg(bool, render_condition_enabled);
1346
1347 pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1348 dstx, dsty, width, height,
1349 render_condition_enabled);
1350
1351 trace_dump_call_end();
1352 }
1353
1354 static inline void
trace_context_clear_texture(struct pipe_context * _pipe,struct pipe_resource * res,unsigned level,const struct pipe_box * box,const void * data)1355 trace_context_clear_texture(struct pipe_context *_pipe,
1356 struct pipe_resource *res,
1357 unsigned level,
1358 const struct pipe_box *box,
1359 const void *data)
1360 {
1361 struct trace_context *tr_ctx = trace_context(_pipe);
1362 struct pipe_context *pipe = tr_ctx->pipe;
1363
1364 res = trace_resource_unwrap(tr_ctx, res);
1365
1366 trace_dump_call_begin("pipe_context", "clear_texture");
1367
1368 trace_dump_arg(ptr, pipe);
1369 trace_dump_arg(ptr, res);
1370 trace_dump_arg(uint, level);
1371 trace_dump_arg_begin("box");
1372 trace_dump_box(box);
1373 trace_dump_arg_end();
1374 trace_dump_arg(ptr, data);
1375
1376 pipe->clear_texture(pipe, res, level, box, data);
1377
1378 trace_dump_call_end();
1379 }
1380
1381 static void
trace_context_flush(struct pipe_context * _pipe,struct pipe_fence_handle ** fence,unsigned flags)1382 trace_context_flush(struct pipe_context *_pipe,
1383 struct pipe_fence_handle **fence,
1384 unsigned flags)
1385 {
1386 struct trace_context *tr_ctx = trace_context(_pipe);
1387 struct pipe_context *pipe = tr_ctx->pipe;
1388
1389 trace_dump_call_begin("pipe_context", "flush");
1390
1391 trace_dump_arg(ptr, pipe);
1392 trace_dump_arg(uint, flags);
1393
1394 pipe->flush(pipe, fence, flags);
1395
1396 if (fence)
1397 trace_dump_ret(ptr, *fence);
1398
1399 trace_dump_call_end();
1400 }
1401
1402
1403 static inline boolean
trace_context_generate_mipmap(struct pipe_context * _pipe,struct pipe_resource * res,enum pipe_format format,unsigned base_level,unsigned last_level,unsigned first_layer,unsigned last_layer)1404 trace_context_generate_mipmap(struct pipe_context *_pipe,
1405 struct pipe_resource *res,
1406 enum pipe_format format,
1407 unsigned base_level,
1408 unsigned last_level,
1409 unsigned first_layer,
1410 unsigned last_layer)
1411 {
1412 struct trace_context *tr_ctx = trace_context(_pipe);
1413 struct pipe_context *pipe = tr_ctx->pipe;
1414 boolean ret;
1415
1416 res = trace_resource_unwrap(tr_ctx, res);
1417
1418 trace_dump_call_begin("pipe_context", "generate_mipmap");
1419
1420 trace_dump_arg(ptr, pipe);
1421 trace_dump_arg(ptr, res);
1422
1423 trace_dump_arg(format, format);
1424 trace_dump_arg(uint, base_level);
1425 trace_dump_arg(uint, last_level);
1426 trace_dump_arg(uint, first_layer);
1427 trace_dump_arg(uint, last_layer);
1428
1429 ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level,
1430 first_layer, last_layer);
1431
1432 trace_dump_ret(bool, ret);
1433 trace_dump_call_end();
1434
1435 return ret;
1436 }
1437
1438
1439 static void
trace_context_destroy(struct pipe_context * _pipe)1440 trace_context_destroy(struct pipe_context *_pipe)
1441 {
1442 struct trace_context *tr_ctx = trace_context(_pipe);
1443 struct pipe_context *pipe = tr_ctx->pipe;
1444
1445 trace_dump_call_begin("pipe_context", "destroy");
1446 trace_dump_arg(ptr, pipe);
1447 trace_dump_call_end();
1448
1449 pipe->destroy(pipe);
1450
1451 FREE(tr_ctx);
1452 }
1453
1454
1455 /********************************************************************
1456 * transfer
1457 */
1458
1459
1460 static void *
trace_context_transfer_map(struct pipe_context * _context,struct pipe_resource * _resource,unsigned level,unsigned usage,const struct pipe_box * box,struct pipe_transfer ** transfer)1461 trace_context_transfer_map(struct pipe_context *_context,
1462 struct pipe_resource *_resource,
1463 unsigned level,
1464 unsigned usage,
1465 const struct pipe_box *box,
1466 struct pipe_transfer **transfer)
1467 {
1468 struct trace_context *tr_context = trace_context(_context);
1469 struct trace_resource *tr_res = trace_resource(_resource);
1470 struct pipe_context *context = tr_context->pipe;
1471 struct pipe_resource *texture = tr_res->resource;
1472 struct pipe_transfer *result = NULL;
1473 void *map;
1474
1475 assert(texture->screen == context->screen);
1476
1477 /*
1478 * Map and transfers can't be serialized so we convert all write transfers
1479 * to texture/buffer_subdata and ignore read transfers.
1480 */
1481
1482 map = context->transfer_map(context, texture, level, usage, box, &result);
1483 if (!map)
1484 return NULL;
1485
1486 *transfer = trace_transfer_create(tr_context, tr_res, result);
1487
1488 if (map) {
1489 if (usage & PIPE_TRANSFER_WRITE) {
1490 trace_transfer(*transfer)->map = map;
1491 }
1492 }
1493
1494 return *transfer ? map : NULL;
1495 }
1496
1497 static void
trace_context_transfer_flush_region(struct pipe_context * _context,struct pipe_transfer * _transfer,const struct pipe_box * box)1498 trace_context_transfer_flush_region( struct pipe_context *_context,
1499 struct pipe_transfer *_transfer,
1500 const struct pipe_box *box)
1501 {
1502 struct trace_context *tr_context = trace_context(_context);
1503 struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1504 struct pipe_context *context = tr_context->pipe;
1505 struct pipe_transfer *transfer = tr_transfer->transfer;
1506
1507 context->transfer_flush_region(context, transfer, box);
1508 }
1509
1510 static void
trace_context_transfer_unmap(struct pipe_context * _context,struct pipe_transfer * _transfer)1511 trace_context_transfer_unmap(struct pipe_context *_context,
1512 struct pipe_transfer *_transfer)
1513 {
1514 struct trace_context *tr_ctx = trace_context(_context);
1515 struct trace_transfer *tr_trans = trace_transfer(_transfer);
1516 struct pipe_context *context = tr_ctx->pipe;
1517 struct pipe_transfer *transfer = tr_trans->transfer;
1518
1519 if (tr_trans->map) {
1520 /*
1521 * Fake a texture/buffer_subdata
1522 */
1523
1524 struct pipe_resource *resource = transfer->resource;
1525 unsigned level = transfer->level;
1526 unsigned usage = transfer->usage;
1527 const struct pipe_box *box = &transfer->box;
1528 unsigned stride = transfer->stride;
1529 unsigned layer_stride = transfer->layer_stride;
1530
1531 if (resource->target == PIPE_BUFFER)
1532 trace_dump_call_begin("pipe_context", "buffer_subdata");
1533 else
1534 trace_dump_call_begin("pipe_context", "texture_subdata");
1535
1536 trace_dump_arg(ptr, context);
1537 trace_dump_arg(ptr, resource);
1538 trace_dump_arg(uint, level);
1539 trace_dump_arg(uint, usage);
1540 trace_dump_arg(box, box);
1541
1542 trace_dump_arg_begin("data");
1543 trace_dump_box_bytes(tr_trans->map,
1544 resource,
1545 box,
1546 stride,
1547 layer_stride);
1548 trace_dump_arg_end();
1549
1550 trace_dump_arg(uint, stride);
1551 trace_dump_arg(uint, layer_stride);
1552
1553 trace_dump_call_end();
1554
1555 tr_trans->map = NULL;
1556 }
1557
1558 context->transfer_unmap(context, transfer);
1559 trace_transfer_destroy(tr_ctx, tr_trans);
1560 }
1561
1562
1563 static void
trace_context_buffer_subdata(struct pipe_context * _context,struct pipe_resource * _resource,unsigned usage,unsigned offset,unsigned size,const void * data)1564 trace_context_buffer_subdata(struct pipe_context *_context,
1565 struct pipe_resource *_resource,
1566 unsigned usage, unsigned offset,
1567 unsigned size, const void *data)
1568 {
1569 struct trace_context *tr_context = trace_context(_context);
1570 struct trace_resource *tr_res = trace_resource(_resource);
1571 struct pipe_context *context = tr_context->pipe;
1572 struct pipe_resource *resource = tr_res->resource;
1573 struct pipe_box box;
1574
1575 assert(resource->screen == context->screen);
1576
1577 trace_dump_call_begin("pipe_context", "buffer_subdata");
1578
1579 trace_dump_arg(ptr, context);
1580 trace_dump_arg(ptr, resource);
1581 trace_dump_arg(uint, usage);
1582 trace_dump_arg(uint, offset);
1583 trace_dump_arg(uint, size);
1584
1585 trace_dump_arg_begin("data");
1586 u_box_1d(offset, size, &box);
1587 trace_dump_box_bytes(data, resource, &box, 0, 0);
1588 trace_dump_arg_end();
1589
1590 trace_dump_call_end();
1591
1592 context->buffer_subdata(context, resource, usage, offset, size, data);
1593 }
1594
1595
1596 static void
trace_context_texture_subdata(struct pipe_context * _context,struct pipe_resource * _resource,unsigned level,unsigned usage,const struct pipe_box * box,const void * data,unsigned stride,unsigned layer_stride)1597 trace_context_texture_subdata(struct pipe_context *_context,
1598 struct pipe_resource *_resource,
1599 unsigned level,
1600 unsigned usage,
1601 const struct pipe_box *box,
1602 const void *data,
1603 unsigned stride,
1604 unsigned layer_stride)
1605 {
1606 struct trace_context *tr_context = trace_context(_context);
1607 struct trace_resource *tr_res = trace_resource(_resource);
1608 struct pipe_context *context = tr_context->pipe;
1609 struct pipe_resource *resource = tr_res->resource;
1610
1611 assert(resource->screen == context->screen);
1612
1613 trace_dump_call_begin("pipe_context", "texture_subdata");
1614
1615 trace_dump_arg(ptr, context);
1616 trace_dump_arg(ptr, resource);
1617 trace_dump_arg(uint, level);
1618 trace_dump_arg(uint, usage);
1619 trace_dump_arg(box, box);
1620
1621 trace_dump_arg_begin("data");
1622 trace_dump_box_bytes(data,
1623 resource,
1624 box,
1625 stride,
1626 layer_stride);
1627 trace_dump_arg_end();
1628
1629 trace_dump_arg(uint, stride);
1630 trace_dump_arg(uint, layer_stride);
1631
1632 trace_dump_call_end();
1633
1634 context->texture_subdata(context, resource, level, usage, box,
1635 data, stride, layer_stride);
1636 }
1637
1638 static void
trace_context_invalidate_resource(struct pipe_context * _context,struct pipe_resource * _resource)1639 trace_context_invalidate_resource(struct pipe_context *_context,
1640 struct pipe_resource *_resource)
1641 {
1642 struct trace_context *tr_context = trace_context(_context);
1643 struct trace_resource *tr_res = trace_resource(_resource);
1644 struct pipe_context *context = tr_context->pipe;
1645 struct pipe_resource *resource = tr_res->resource;
1646
1647 assert(resource->screen == context->screen);
1648
1649 trace_dump_call_begin("pipe_context", "invalidate_resource");
1650
1651 trace_dump_arg(ptr, context);
1652 trace_dump_arg(ptr, resource);
1653
1654 trace_dump_call_end();
1655
1656 context->invalidate_resource(context, resource);
1657 }
1658
1659 static void
trace_context_render_condition(struct pipe_context * _context,struct pipe_query * query,boolean condition,uint mode)1660 trace_context_render_condition(struct pipe_context *_context,
1661 struct pipe_query *query,
1662 boolean condition,
1663 uint mode)
1664 {
1665 struct trace_context *tr_context = trace_context(_context);
1666 struct pipe_context *context = tr_context->pipe;
1667
1668 query = trace_query_unwrap(query);
1669
1670 trace_dump_call_begin("pipe_context", "render_condition");
1671
1672 trace_dump_arg(ptr, context);
1673 trace_dump_arg(ptr, query);
1674 trace_dump_arg(bool, condition);
1675 trace_dump_arg(uint, mode);
1676
1677 trace_dump_call_end();
1678
1679 context->render_condition(context, query, condition, mode);
1680 }
1681
1682
1683 static void
trace_context_texture_barrier(struct pipe_context * _context,unsigned flags)1684 trace_context_texture_barrier(struct pipe_context *_context, unsigned flags)
1685 {
1686 struct trace_context *tr_context = trace_context(_context);
1687 struct pipe_context *context = tr_context->pipe;
1688
1689 trace_dump_call_begin("pipe_context", "texture_barrier");
1690
1691 trace_dump_arg(ptr, context);
1692 trace_dump_arg(uint, flags);
1693
1694 trace_dump_call_end();
1695
1696 context->texture_barrier(context, flags);
1697 }
1698
1699
1700 static void
trace_context_memory_barrier(struct pipe_context * _context,unsigned flags)1701 trace_context_memory_barrier(struct pipe_context *_context,
1702 unsigned flags)
1703 {
1704 struct trace_context *tr_context = trace_context(_context);
1705 struct pipe_context *context = tr_context->pipe;
1706
1707 trace_dump_call_begin("pipe_context", "memory_barrier");
1708 trace_dump_arg(ptr, context);
1709 trace_dump_arg(uint, flags);
1710 trace_dump_call_end();
1711
1712 context->memory_barrier(context, flags);
1713 }
1714
1715
1716 static void
trace_context_set_tess_state(struct pipe_context * _context,const float default_outer_level[4],const float default_inner_level[2])1717 trace_context_set_tess_state(struct pipe_context *_context,
1718 const float default_outer_level[4],
1719 const float default_inner_level[2])
1720 {
1721 struct trace_context *tr_context = trace_context(_context);
1722 struct pipe_context *context = tr_context->pipe;
1723
1724 trace_dump_call_begin("pipe_context", "set_tess_state");
1725 trace_dump_arg(ptr, context);
1726 trace_dump_arg_array(float, default_outer_level, 4);
1727 trace_dump_arg_array(float, default_inner_level, 2);
1728 trace_dump_call_end();
1729
1730 context->set_tess_state(context, default_outer_level, default_inner_level);
1731 }
1732
1733
trace_context_set_shader_buffers(struct pipe_context * _context,enum pipe_shader_type shader,unsigned start,unsigned nr,const struct pipe_shader_buffer * buffers)1734 static void trace_context_set_shader_buffers(struct pipe_context *_context,
1735 enum pipe_shader_type shader,
1736 unsigned start, unsigned nr,
1737 const struct pipe_shader_buffer *buffers)
1738 {
1739 struct trace_context *tr_context = trace_context(_context);
1740 struct pipe_context *context = tr_context->pipe;
1741 struct pipe_shader_buffer *_buffers = NULL;
1742
1743 trace_dump_call_begin("pipe_context", "set_shader_buffers");
1744 trace_dump_arg(ptr, context);
1745 trace_dump_arg(uint, shader);
1746 trace_dump_arg(uint, start);
1747 trace_dump_arg_begin("buffers");
1748 trace_dump_struct_array(shader_buffer, buffers, nr);
1749 trace_dump_arg_end();
1750 trace_dump_call_end();
1751
1752 if (buffers) {
1753 int i;
1754
1755 _buffers = MALLOC(nr * sizeof(struct pipe_shader_buffer));
1756 if (!_buffers)
1757 return;
1758
1759 for (i = 0; i < nr; i++) {
1760 _buffers[i] = buffers[i];
1761 _buffers[i].buffer = trace_resource_unwrap(
1762 tr_context, _buffers[i].buffer);
1763 }
1764 }
1765
1766 context->set_shader_buffers(context, shader, start, nr, _buffers);
1767
1768 if (_buffers)
1769 FREE(_buffers);
1770 }
1771
trace_context_set_shader_images(struct pipe_context * _context,enum pipe_shader_type shader,unsigned start,unsigned nr,const struct pipe_image_view * images)1772 static void trace_context_set_shader_images(struct pipe_context *_context,
1773 enum pipe_shader_type shader,
1774 unsigned start, unsigned nr,
1775 const struct pipe_image_view *images)
1776 {
1777 struct trace_context *tr_context = trace_context(_context);
1778 struct pipe_context *context = tr_context->pipe;
1779 struct pipe_image_view *_images = NULL;
1780
1781 trace_dump_call_begin("pipe_context", "set_shader_images");
1782 trace_dump_arg(ptr, context);
1783 trace_dump_arg(uint, shader);
1784 trace_dump_arg(uint, start);
1785 trace_dump_arg_begin("images");
1786 trace_dump_struct_array(image_view, images, nr);
1787 trace_dump_arg_end();
1788 trace_dump_call_end();
1789
1790 if (images) {
1791 int i;
1792
1793 _images = MALLOC(nr * sizeof(struct pipe_image_view));
1794 if (!_images)
1795 return;
1796
1797 for (i = 0; i < nr; i++) {
1798 _images[i] = images[i];
1799 _images[i].resource = trace_resource_unwrap(tr_context,
1800 _images[i].resource);
1801 }
1802 }
1803
1804 context->set_shader_images(context, shader, start, nr, _images);
1805
1806 if (_images)
1807 FREE(_images);
1808 }
1809
trace_context_launch_grid(struct pipe_context * _pipe,const struct pipe_grid_info * info)1810 static void trace_context_launch_grid(struct pipe_context *_pipe,
1811 const struct pipe_grid_info *info)
1812 {
1813 struct trace_context *tr_ctx = trace_context(_pipe);
1814 struct pipe_context *pipe = tr_ctx->pipe;
1815
1816 trace_dump_call_begin("pipe_context", "launch_grid");
1817
1818 trace_dump_arg(ptr, pipe);
1819 trace_dump_arg(grid_info, info);
1820
1821 trace_dump_trace_flush();
1822
1823 if (info->indirect) {
1824 struct pipe_grid_info _info;
1825
1826 memcpy(&_info, info, sizeof(_info));
1827 _info.indirect = trace_resource_unwrap(tr_ctx, _info.indirect);
1828 pipe->launch_grid(pipe, &_info);
1829 } else {
1830 pipe->launch_grid(pipe, info);
1831 }
1832
1833 trace_dump_call_end();
1834 }
1835
1836 struct pipe_context *
trace_context_create(struct trace_screen * tr_scr,struct pipe_context * pipe)1837 trace_context_create(struct trace_screen *tr_scr,
1838 struct pipe_context *pipe)
1839 {
1840 struct trace_context *tr_ctx;
1841
1842 if (!pipe)
1843 goto error1;
1844
1845 if (!trace_enabled())
1846 goto error1;
1847
1848 tr_ctx = CALLOC_STRUCT(trace_context);
1849 if (!tr_ctx)
1850 goto error1;
1851
1852 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1853 tr_ctx->base.screen = &tr_scr->base;
1854
1855 tr_ctx->base.destroy = trace_context_destroy;
1856
1857 #define TR_CTX_INIT(_member) \
1858 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1859
1860 TR_CTX_INIT(draw_vbo);
1861 TR_CTX_INIT(render_condition);
1862 TR_CTX_INIT(create_query);
1863 TR_CTX_INIT(destroy_query);
1864 TR_CTX_INIT(begin_query);
1865 TR_CTX_INIT(end_query);
1866 TR_CTX_INIT(get_query_result);
1867 TR_CTX_INIT(set_active_query_state);
1868 TR_CTX_INIT(create_blend_state);
1869 TR_CTX_INIT(bind_blend_state);
1870 TR_CTX_INIT(delete_blend_state);
1871 TR_CTX_INIT(create_sampler_state);
1872 TR_CTX_INIT(bind_sampler_states);
1873 TR_CTX_INIT(delete_sampler_state);
1874 TR_CTX_INIT(create_rasterizer_state);
1875 TR_CTX_INIT(bind_rasterizer_state);
1876 TR_CTX_INIT(delete_rasterizer_state);
1877 TR_CTX_INIT(create_depth_stencil_alpha_state);
1878 TR_CTX_INIT(bind_depth_stencil_alpha_state);
1879 TR_CTX_INIT(delete_depth_stencil_alpha_state);
1880 TR_CTX_INIT(create_fs_state);
1881 TR_CTX_INIT(bind_fs_state);
1882 TR_CTX_INIT(delete_fs_state);
1883 TR_CTX_INIT(create_vs_state);
1884 TR_CTX_INIT(bind_vs_state);
1885 TR_CTX_INIT(delete_vs_state);
1886 TR_CTX_INIT(create_gs_state);
1887 TR_CTX_INIT(bind_gs_state);
1888 TR_CTX_INIT(delete_gs_state);
1889 TR_CTX_INIT(create_tcs_state);
1890 TR_CTX_INIT(bind_tcs_state);
1891 TR_CTX_INIT(delete_tcs_state);
1892 TR_CTX_INIT(create_tes_state);
1893 TR_CTX_INIT(bind_tes_state);
1894 TR_CTX_INIT(delete_tes_state);
1895 TR_CTX_INIT(create_compute_state);
1896 TR_CTX_INIT(bind_compute_state);
1897 TR_CTX_INIT(delete_compute_state);
1898 TR_CTX_INIT(create_vertex_elements_state);
1899 TR_CTX_INIT(bind_vertex_elements_state);
1900 TR_CTX_INIT(delete_vertex_elements_state);
1901 TR_CTX_INIT(set_blend_color);
1902 TR_CTX_INIT(set_stencil_ref);
1903 TR_CTX_INIT(set_clip_state);
1904 TR_CTX_INIT(set_sample_mask);
1905 TR_CTX_INIT(set_constant_buffer);
1906 TR_CTX_INIT(set_framebuffer_state);
1907 TR_CTX_INIT(set_polygon_stipple);
1908 TR_CTX_INIT(set_scissor_states);
1909 TR_CTX_INIT(set_viewport_states);
1910 TR_CTX_INIT(set_sampler_views);
1911 TR_CTX_INIT(create_sampler_view);
1912 TR_CTX_INIT(sampler_view_destroy);
1913 TR_CTX_INIT(create_surface);
1914 TR_CTX_INIT(surface_destroy);
1915 TR_CTX_INIT(set_vertex_buffers);
1916 TR_CTX_INIT(set_index_buffer);
1917 TR_CTX_INIT(create_stream_output_target);
1918 TR_CTX_INIT(stream_output_target_destroy);
1919 TR_CTX_INIT(set_stream_output_targets);
1920 TR_CTX_INIT(resource_copy_region);
1921 TR_CTX_INIT(blit);
1922 TR_CTX_INIT(flush_resource);
1923 TR_CTX_INIT(clear);
1924 TR_CTX_INIT(clear_render_target);
1925 TR_CTX_INIT(clear_depth_stencil);
1926 TR_CTX_INIT(clear_texture);
1927 TR_CTX_INIT(flush);
1928 TR_CTX_INIT(generate_mipmap);
1929 TR_CTX_INIT(texture_barrier);
1930 TR_CTX_INIT(memory_barrier);
1931 TR_CTX_INIT(set_tess_state);
1932 TR_CTX_INIT(set_shader_buffers);
1933 TR_CTX_INIT(launch_grid);
1934 TR_CTX_INIT(set_shader_images);
1935
1936 TR_CTX_INIT(transfer_map);
1937 TR_CTX_INIT(transfer_unmap);
1938 TR_CTX_INIT(transfer_flush_region);
1939 TR_CTX_INIT(buffer_subdata);
1940 TR_CTX_INIT(texture_subdata);
1941 TR_CTX_INIT(invalidate_resource);
1942
1943 #undef TR_CTX_INIT
1944
1945 tr_ctx->pipe = pipe;
1946
1947 return &tr_ctx->base;
1948
1949 error1:
1950 return pipe;
1951 }
1952
1953
1954 /**
1955 * Sanity checker: check that the given context really is a
1956 * trace context (and not the wrapped driver's context).
1957 */
1958 void
trace_context_check(const struct pipe_context * pipe)1959 trace_context_check(const struct pipe_context *pipe)
1960 {
1961 MAYBE_UNUSED struct trace_context *tr_ctx = (struct trace_context *) pipe;
1962 assert(tr_ctx->base.destroy == trace_context_destroy);
1963 }
1964