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