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