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