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