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