1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 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 VMWARE 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/simple_list.h" 31 32 #include "pipe/p_format.h" 33 #include "pipe/p_screen.h" 34 35 #include "tr_dump.h" 36 #include "tr_dump_defines.h" 37 #include "tr_dump_state.h" 38 #include "tr_public.h" 39 #include "tr_screen.h" 40 #include "tr_texture.h" 41 #include "tr_context.h" 42 43 44 struct trace_query 45 { 46 unsigned type; 47 48 struct pipe_query *query; 49 }; 50 51 52 static inline struct trace_query * 53 trace_query(struct pipe_query *query) 54 { 55 return (struct trace_query *)query; 56 } 57 58 59 static inline struct pipe_query * 60 trace_query_unwrap(struct pipe_query *query) 61 { 62 if (query) { 63 return trace_query(query)->query; 64 } else { 65 return NULL; 66 } 67 } 68 69 70 static inline struct pipe_resource * 71 trace_resource_unwrap(struct trace_context *tr_ctx, 72 struct pipe_resource *resource) 73 { 74 struct trace_resource *tr_res; 75 76 if (!resource) 77 return NULL; 78 79 tr_res = trace_resource(resource); 80 81 assert(tr_res->resource); 82 return tr_res->resource; 83 } 84 85 86 static inline struct pipe_surface * 87 trace_surface_unwrap(struct trace_context *tr_ctx, 88 struct pipe_surface *surface) 89 { 90 struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen); 91 struct trace_surface *tr_surf; 92 93 if (!surface) 94 return NULL; 95 96 assert(surface->texture); 97 if (!surface->texture) 98 return surface; 99 100 tr_surf = trace_surface(surface); 101 102 assert(tr_surf->surface); 103 assert(tr_surf->surface->texture->screen == tr_scr->screen); 104 (void) tr_scr; 105 return tr_surf->surface; 106 } 107 108 109 static void 110 trace_context_draw_vbo(struct pipe_context *_pipe, 111 const struct pipe_draw_info *info) 112 { 113 struct trace_context *tr_ctx = trace_context(_pipe); 114 struct pipe_context *pipe = tr_ctx->pipe; 115 116 trace_dump_call_begin("pipe_context", "draw_vbo"); 117 118 trace_dump_arg(ptr, pipe); 119 trace_dump_arg(draw_info, info); 120 121 trace_dump_trace_flush(); 122 123 if (info->indirect) { 124 struct pipe_draw_info _info; 125 126 memcpy(&_info, info, sizeof(_info)); 127 _info.indirect = trace_resource_unwrap(tr_ctx, _info.indirect); 128 _info.indirect_params = trace_resource_unwrap(tr_ctx, 129 _info.indirect_params); 130 pipe->draw_vbo(pipe, &_info); 131 } else { 132 pipe->draw_vbo(pipe, info); 133 } 134 135 trace_dump_call_end(); 136 } 137 138 139 static struct pipe_query * 140 trace_context_create_query(struct pipe_context *_pipe, 141 unsigned query_type, 142 unsigned index) 143 { 144 struct trace_context *tr_ctx = trace_context(_pipe); 145 struct pipe_context *pipe = tr_ctx->pipe; 146 struct pipe_query *query; 147 148 trace_dump_call_begin("pipe_context", "create_query"); 149 150 trace_dump_arg(ptr, pipe); 151 trace_dump_arg(query_type, query_type); 152 trace_dump_arg(int, index); 153 154 query = pipe->create_query(pipe, query_type, index); 155 156 trace_dump_ret(ptr, query); 157 158 trace_dump_call_end(); 159 160 /* Wrap query object. */ 161 if (query) { 162 struct trace_query *tr_query = CALLOC_STRUCT(trace_query); 163 if (tr_query) { 164 tr_query->type = query_type; 165 tr_query->query = query; 166 query = (struct pipe_query *)tr_query; 167 } else { 168 pipe->destroy_query(pipe, query); 169 query = NULL; 170 } 171 } 172 173 return query; 174 } 175 176 177 static void 178 trace_context_destroy_query(struct pipe_context *_pipe, 179 struct pipe_query *_query) 180 { 181 struct trace_context *tr_ctx = trace_context(_pipe); 182 struct pipe_context *pipe = tr_ctx->pipe; 183 struct trace_query *tr_query = trace_query(_query); 184 struct pipe_query *query = tr_query->query; 185 186 FREE(tr_query); 187 188 trace_dump_call_begin("pipe_context", "destroy_query"); 189 190 trace_dump_arg(ptr, pipe); 191 trace_dump_arg(ptr, query); 192 193 pipe->destroy_query(pipe, query); 194 195 trace_dump_call_end(); 196 } 197 198 199 static boolean 200 trace_context_begin_query(struct pipe_context *_pipe, 201 struct pipe_query *query) 202 { 203 struct trace_context *tr_ctx = trace_context(_pipe); 204 struct pipe_context *pipe = tr_ctx->pipe; 205 boolean ret; 206 207 query = trace_query_unwrap(query); 208 209 trace_dump_call_begin("pipe_context", "begin_query"); 210 211 trace_dump_arg(ptr, pipe); 212 trace_dump_arg(ptr, query); 213 214 ret = pipe->begin_query(pipe, query); 215 216 trace_dump_call_end(); 217 return ret; 218 } 219 220 221 static bool 222 trace_context_end_query(struct pipe_context *_pipe, 223 struct pipe_query *query) 224 { 225 struct trace_context *tr_ctx = trace_context(_pipe); 226 struct pipe_context *pipe = tr_ctx->pipe; 227 bool ret; 228 229 query = trace_query_unwrap(query); 230 231 trace_dump_call_begin("pipe_context", "end_query"); 232 233 trace_dump_arg(ptr, pipe); 234 trace_dump_arg(ptr, query); 235 236 ret = pipe->end_query(pipe, query); 237 238 trace_dump_call_end(); 239 return ret; 240 } 241 242 243 static boolean 244 trace_context_get_query_result(struct pipe_context *_pipe, 245 struct pipe_query *_query, 246 boolean wait, 247 union pipe_query_result *result) 248 { 249 struct trace_context *tr_ctx = trace_context(_pipe); 250 struct pipe_context *pipe = tr_ctx->pipe; 251 struct trace_query *tr_query = trace_query(_query); 252 struct pipe_query *query = tr_query->query; 253 boolean ret; 254 255 trace_dump_call_begin("pipe_context", "get_query_result"); 256 257 trace_dump_arg(ptr, pipe); 258 trace_dump_arg(ptr, query); 259 260 ret = pipe->get_query_result(pipe, query, wait, result); 261 262 trace_dump_arg_begin("result"); 263 if (ret) { 264 trace_dump_query_result(tr_query->type, result); 265 } else { 266 trace_dump_null(); 267 } 268 trace_dump_arg_end(); 269 270 trace_dump_ret(bool, ret); 271 272 trace_dump_call_end(); 273 274 return ret; 275 } 276 277 278 static void 279 trace_context_set_active_query_state(struct pipe_context *_pipe, 280 boolean enable) 281 { 282 struct trace_context *tr_ctx = trace_context(_pipe); 283 struct pipe_context *pipe = tr_ctx->pipe; 284 285 trace_dump_call_begin("pipe_context", "set_active_query_state"); 286 287 trace_dump_arg(ptr, pipe); 288 trace_dump_arg(bool, enable); 289 290 pipe->set_active_query_state(pipe, enable); 291 292 trace_dump_call_end(); 293 } 294 295 296 static void * 297 trace_context_create_blend_state(struct pipe_context *_pipe, 298 const struct pipe_blend_state *state) 299 { 300 struct trace_context *tr_ctx = trace_context(_pipe); 301 struct pipe_context *pipe = tr_ctx->pipe; 302 void * result; 303 304 trace_dump_call_begin("pipe_context", "create_blend_state"); 305 306 trace_dump_arg(ptr, pipe); 307 trace_dump_arg(blend_state, state); 308 309 result = pipe->create_blend_state(pipe, state); 310 311 trace_dump_ret(ptr, result); 312 313 trace_dump_call_end(); 314 315 return result; 316 } 317 318 319 static void 320 trace_context_bind_blend_state(struct pipe_context *_pipe, 321 void *state) 322 { 323 struct trace_context *tr_ctx = trace_context(_pipe); 324 struct pipe_context *pipe = tr_ctx->pipe; 325 326 trace_dump_call_begin("pipe_context", "bind_blend_state"); 327 328 trace_dump_arg(ptr, pipe); 329 trace_dump_arg(ptr, state); 330 331 pipe->bind_blend_state(pipe, state); 332 333 trace_dump_call_end(); 334 } 335 336 337 static void 338 trace_context_delete_blend_state(struct pipe_context *_pipe, 339 void *state) 340 { 341 struct trace_context *tr_ctx = trace_context(_pipe); 342 struct pipe_context *pipe = tr_ctx->pipe; 343 344 trace_dump_call_begin("pipe_context", "delete_blend_state"); 345 346 trace_dump_arg(ptr, pipe); 347 trace_dump_arg(ptr, state); 348 349 pipe->delete_blend_state(pipe, state); 350 351 trace_dump_call_end(); 352 } 353 354 355 static void * 356 trace_context_create_sampler_state(struct pipe_context *_pipe, 357 const struct pipe_sampler_state *state) 358 { 359 struct trace_context *tr_ctx = trace_context(_pipe); 360 struct pipe_context *pipe = tr_ctx->pipe; 361 void * result; 362 363 trace_dump_call_begin("pipe_context", "create_sampler_state"); 364 365 trace_dump_arg(ptr, pipe); 366 trace_dump_arg(sampler_state, state); 367 368 result = pipe->create_sampler_state(pipe, state); 369 370 trace_dump_ret(ptr, result); 371 372 trace_dump_call_end(); 373 374 return result; 375 } 376 377 378 static void 379 trace_context_bind_sampler_states(struct pipe_context *_pipe, 380 enum pipe_shader_type shader, 381 unsigned start, 382 unsigned num_states, 383 void **states) 384 { 385 struct trace_context *tr_ctx = trace_context(_pipe); 386 struct pipe_context *pipe = tr_ctx->pipe; 387 388 /* remove this when we have pipe->bind_sampler_states(..., start, ...) */ 389 assert(start == 0); 390 391 trace_dump_call_begin("pipe_context", "bind_sampler_states"); 392 393 trace_dump_arg(ptr, pipe); 394 trace_dump_arg(uint, shader); 395 trace_dump_arg(uint, start); 396 trace_dump_arg(uint, num_states); 397 trace_dump_arg_array(ptr, states, num_states); 398 399 pipe->bind_sampler_states(pipe, shader, start, num_states, states); 400 401 trace_dump_call_end(); 402 } 403 404 405 static void 406 trace_context_delete_sampler_state(struct pipe_context *_pipe, 407 void *state) 408 { 409 struct trace_context *tr_ctx = trace_context(_pipe); 410 struct pipe_context *pipe = tr_ctx->pipe; 411 412 trace_dump_call_begin("pipe_context", "delete_sampler_state"); 413 414 trace_dump_arg(ptr, pipe); 415 trace_dump_arg(ptr, state); 416 417 pipe->delete_sampler_state(pipe, state); 418 419 trace_dump_call_end(); 420 } 421 422 423 static void * 424 trace_context_create_rasterizer_state(struct pipe_context *_pipe, 425 const struct pipe_rasterizer_state *state) 426 { 427 struct trace_context *tr_ctx = trace_context(_pipe); 428 struct pipe_context *pipe = tr_ctx->pipe; 429 void * result; 430 431 trace_dump_call_begin("pipe_context", "create_rasterizer_state"); 432 433 trace_dump_arg(ptr, pipe); 434 trace_dump_arg(rasterizer_state, state); 435 436 result = pipe->create_rasterizer_state(pipe, state); 437 438 trace_dump_ret(ptr, result); 439 440 trace_dump_call_end(); 441 442 return result; 443 } 444 445 446 static void 447 trace_context_bind_rasterizer_state(struct pipe_context *_pipe, 448 void *state) 449 { 450 struct trace_context *tr_ctx = trace_context(_pipe); 451 struct pipe_context *pipe = tr_ctx->pipe; 452 453 trace_dump_call_begin("pipe_context", "bind_rasterizer_state"); 454 455 trace_dump_arg(ptr, pipe); 456 trace_dump_arg(ptr, state); 457 458 pipe->bind_rasterizer_state(pipe, state); 459 460 trace_dump_call_end(); 461 } 462 463 464 static void 465 trace_context_delete_rasterizer_state(struct pipe_context *_pipe, 466 void *state) 467 { 468 struct trace_context *tr_ctx = trace_context(_pipe); 469 struct pipe_context *pipe = tr_ctx->pipe; 470 471 trace_dump_call_begin("pipe_context", "delete_rasterizer_state"); 472 473 trace_dump_arg(ptr, pipe); 474 trace_dump_arg(ptr, state); 475 476 pipe->delete_rasterizer_state(pipe, state); 477 478 trace_dump_call_end(); 479 } 480 481 482 static void * 483 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe, 484 const struct pipe_depth_stencil_alpha_state *state) 485 { 486 struct trace_context *tr_ctx = trace_context(_pipe); 487 struct pipe_context *pipe = tr_ctx->pipe; 488 void * result; 489 490 trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state"); 491 492 result = pipe->create_depth_stencil_alpha_state(pipe, state); 493 494 trace_dump_arg(ptr, pipe); 495 trace_dump_arg(depth_stencil_alpha_state, state); 496 497 trace_dump_ret(ptr, result); 498 499 trace_dump_call_end(); 500 501 return result; 502 } 503 504 505 static void 506 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe, 507 void *state) 508 { 509 struct trace_context *tr_ctx = trace_context(_pipe); 510 struct pipe_context *pipe = tr_ctx->pipe; 511 512 trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state"); 513 514 trace_dump_arg(ptr, pipe); 515 trace_dump_arg(ptr, state); 516 517 pipe->bind_depth_stencil_alpha_state(pipe, state); 518 519 trace_dump_call_end(); 520 } 521 522 523 static void 524 trace_context_delete_depth_stencil_alpha_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", "delete_depth_stencil_alpha_state"); 531 532 trace_dump_arg(ptr, pipe); 533 trace_dump_arg(ptr, state); 534 535 pipe->delete_depth_stencil_alpha_state(pipe, state); 536 537 trace_dump_call_end(); 538 } 539 540 541 #define TRACE_SHADER_STATE(shader_type) \ 542 static void * \ 543 trace_context_create_##shader_type##_state(struct pipe_context *_pipe, \ 544 const struct pipe_shader_state *state) \ 545 { \ 546 struct trace_context *tr_ctx = trace_context(_pipe); \ 547 struct pipe_context *pipe = tr_ctx->pipe; \ 548 void * result; \ 549 trace_dump_call_begin("pipe_context", "create_" #shader_type "_state"); \ 550 trace_dump_arg(ptr, pipe); \ 551 trace_dump_arg(shader_state, state); \ 552 result = pipe->create_##shader_type##_state(pipe, state); \ 553 trace_dump_ret(ptr, result); \ 554 trace_dump_call_end(); \ 555 return result; \ 556 } \ 557 \ 558 static void \ 559 trace_context_bind_##shader_type##_state(struct pipe_context *_pipe, \ 560 void *state) \ 561 { \ 562 struct trace_context *tr_ctx = trace_context(_pipe); \ 563 struct pipe_context *pipe = tr_ctx->pipe; \ 564 trace_dump_call_begin("pipe_context", "bind_" #shader_type "_state"); \ 565 trace_dump_arg(ptr, pipe); \ 566 trace_dump_arg(ptr, state); \ 567 pipe->bind_##shader_type##_state(pipe, state); \ 568 trace_dump_call_end(); \ 569 } \ 570 \ 571 static void \ 572 trace_context_delete_##shader_type##_state(struct pipe_context *_pipe, \ 573 void *state) \ 574 { \ 575 struct trace_context *tr_ctx = trace_context(_pipe); \ 576 struct pipe_context *pipe = tr_ctx->pipe; \ 577 trace_dump_call_begin("pipe_context", "delete_" #shader_type "_state"); \ 578 trace_dump_arg(ptr, pipe); \ 579 trace_dump_arg(ptr, state); \ 580 pipe->delete_##shader_type##_state(pipe, state); \ 581 trace_dump_call_end(); \ 582 } 583 584 TRACE_SHADER_STATE(fs) 585 TRACE_SHADER_STATE(vs) 586 TRACE_SHADER_STATE(gs) 587 TRACE_SHADER_STATE(tcs) 588 TRACE_SHADER_STATE(tes) 589 590 #undef TRACE_SHADER_STATE 591 592 593 static inline void * 594 trace_context_create_compute_state(struct pipe_context *_pipe, 595 const struct pipe_compute_state *state) 596 { 597 struct trace_context *tr_ctx = trace_context(_pipe); 598 struct pipe_context *pipe = tr_ctx->pipe; 599 void * result; 600 601 trace_dump_call_begin("pipe_context", "create_compute_state"); 602 trace_dump_arg(ptr, pipe); 603 trace_dump_arg(compute_state, state); 604 result = pipe->create_compute_state(pipe, state); 605 trace_dump_ret(ptr, result); 606 trace_dump_call_end(); 607 return result; 608 } 609 610 static inline void 611 trace_context_bind_compute_state(struct pipe_context *_pipe, 612 void *state) 613 { 614 struct trace_context *tr_ctx = trace_context(_pipe); 615 struct pipe_context *pipe = tr_ctx->pipe; 616 617 trace_dump_call_begin("pipe_context", "bind_compute_state"); 618 trace_dump_arg(ptr, pipe); 619 trace_dump_arg(ptr, state); 620 pipe->bind_compute_state(pipe, state); 621 trace_dump_call_end(); 622 } 623 624 static inline void 625 trace_context_delete_compute_state(struct pipe_context *_pipe, 626 void *state) 627 { 628 struct trace_context *tr_ctx = trace_context(_pipe); 629 struct pipe_context *pipe = tr_ctx->pipe; 630 631 trace_dump_call_begin("pipe_context", "delete_compute_state"); 632 trace_dump_arg(ptr, pipe); 633 trace_dump_arg(ptr, state); 634 pipe->delete_compute_state(pipe, state); 635 trace_dump_call_end(); 636 } 637 638 static void * 639 trace_context_create_vertex_elements_state(struct pipe_context *_pipe, 640 unsigned num_elements, 641 const struct pipe_vertex_element *elements) 642 { 643 struct trace_context *tr_ctx = trace_context(_pipe); 644 struct pipe_context *pipe = tr_ctx->pipe; 645 void * result; 646 647 trace_dump_call_begin("pipe_context", "create_vertex_elements_state"); 648 649 trace_dump_arg(ptr, pipe); 650 trace_dump_arg(uint, num_elements); 651 652 trace_dump_arg_begin("elements"); 653 trace_dump_struct_array(vertex_element, elements, num_elements); 654 trace_dump_arg_end(); 655 656 result = pipe->create_vertex_elements_state(pipe, num_elements, elements); 657 658 trace_dump_ret(ptr, result); 659 660 trace_dump_call_end(); 661 662 return result; 663 } 664 665 666 static void 667 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe, 668 void *state) 669 { 670 struct trace_context *tr_ctx = trace_context(_pipe); 671 struct pipe_context *pipe = tr_ctx->pipe; 672 673 trace_dump_call_begin("pipe_context", "bind_vertex_elements_state"); 674 675 trace_dump_arg(ptr, pipe); 676 trace_dump_arg(ptr, state); 677 678 pipe->bind_vertex_elements_state(pipe, state); 679 680 trace_dump_call_end(); 681 } 682 683 684 static void 685 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe, 686 void *state) 687 { 688 struct trace_context *tr_ctx = trace_context(_pipe); 689 struct pipe_context *pipe = tr_ctx->pipe; 690 691 trace_dump_call_begin("pipe_context", "delete_vertex_elements_state"); 692 693 trace_dump_arg(ptr, pipe); 694 trace_dump_arg(ptr, state); 695 696 pipe->delete_vertex_elements_state(pipe, state); 697 698 trace_dump_call_end(); 699 } 700 701 702 static void 703 trace_context_set_blend_color(struct pipe_context *_pipe, 704 const struct pipe_blend_color *state) 705 { 706 struct trace_context *tr_ctx = trace_context(_pipe); 707 struct pipe_context *pipe = tr_ctx->pipe; 708 709 trace_dump_call_begin("pipe_context", "set_blend_color"); 710 711 trace_dump_arg(ptr, pipe); 712 trace_dump_arg(blend_color, state); 713 714 pipe->set_blend_color(pipe, state); 715 716 trace_dump_call_end(); 717 } 718 719 720 static void 721 trace_context_set_stencil_ref(struct pipe_context *_pipe, 722 const struct pipe_stencil_ref *state) 723 { 724 struct trace_context *tr_ctx = trace_context(_pipe); 725 struct pipe_context *pipe = tr_ctx->pipe; 726 727 trace_dump_call_begin("pipe_context", "set_stencil_ref"); 728 729 trace_dump_arg(ptr, pipe); 730 trace_dump_arg(stencil_ref, state); 731 732 pipe->set_stencil_ref(pipe, state); 733 734 trace_dump_call_end(); 735 } 736 737 738 static void 739 trace_context_set_clip_state(struct pipe_context *_pipe, 740 const struct pipe_clip_state *state) 741 { 742 struct trace_context *tr_ctx = trace_context(_pipe); 743 struct pipe_context *pipe = tr_ctx->pipe; 744 745 trace_dump_call_begin("pipe_context", "set_clip_state"); 746 747 trace_dump_arg(ptr, pipe); 748 trace_dump_arg(clip_state, state); 749 750 pipe->set_clip_state(pipe, state); 751 752 trace_dump_call_end(); 753 } 754 755 static void 756 trace_context_set_sample_mask(struct pipe_context *_pipe, 757 unsigned sample_mask) 758 { 759 struct trace_context *tr_ctx = trace_context(_pipe); 760 struct pipe_context *pipe = tr_ctx->pipe; 761 762 trace_dump_call_begin("pipe_context", "set_sample_mask"); 763 764 trace_dump_arg(ptr, pipe); 765 trace_dump_arg(uint, sample_mask); 766 767 pipe->set_sample_mask(pipe, sample_mask); 768 769 trace_dump_call_end(); 770 } 771 772 static void 773 trace_context_set_constant_buffer(struct pipe_context *_pipe, 774 uint shader, uint index, 775 const struct pipe_constant_buffer *constant_buffer) 776 { 777 struct trace_context *tr_ctx = trace_context(_pipe); 778 struct pipe_context *pipe = tr_ctx->pipe; 779 struct pipe_constant_buffer cb; 780 781 if (constant_buffer) { 782 cb = *constant_buffer; 783 cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer); 784 constant_buffer = &cb; 785 } 786 787 trace_dump_call_begin("pipe_context", "set_constant_buffer"); 788 789 trace_dump_arg(ptr, pipe); 790 trace_dump_arg(uint, shader); 791 trace_dump_arg(uint, index); 792 trace_dump_arg(constant_buffer, constant_buffer); 793 794 pipe->set_constant_buffer(pipe, shader, index, constant_buffer); 795 796 trace_dump_call_end(); 797 } 798 799 800 static void 801 trace_context_set_framebuffer_state(struct pipe_context *_pipe, 802 const struct pipe_framebuffer_state *state) 803 { 804 struct trace_context *tr_ctx = trace_context(_pipe); 805 struct pipe_context *pipe = tr_ctx->pipe; 806 struct pipe_framebuffer_state unwrapped_state; 807 unsigned i; 808 809 810 /* Unwrap the input state */ 811 memcpy(&unwrapped_state, state, sizeof(unwrapped_state)); 812 for (i = 0; i < state->nr_cbufs; ++i) 813 unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]); 814 for (i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i) 815 unwrapped_state.cbufs[i] = NULL; 816 unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf); 817 state = &unwrapped_state; 818 819 trace_dump_call_begin("pipe_context", "set_framebuffer_state"); 820 821 trace_dump_arg(ptr, pipe); 822 trace_dump_arg(framebuffer_state, state); 823 824 pipe->set_framebuffer_state(pipe, state); 825 826 trace_dump_call_end(); 827 } 828 829 830 static void 831 trace_context_set_polygon_stipple(struct pipe_context *_pipe, 832 const struct pipe_poly_stipple *state) 833 { 834 struct trace_context *tr_ctx = trace_context(_pipe); 835 struct pipe_context *pipe = tr_ctx->pipe; 836 837 trace_dump_call_begin("pipe_context", "set_polygon_stipple"); 838 839 trace_dump_arg(ptr, pipe); 840 trace_dump_arg(poly_stipple, state); 841 842 pipe->set_polygon_stipple(pipe, state); 843 844 trace_dump_call_end(); 845 } 846 847 848 static void 849 trace_context_set_scissor_states(struct pipe_context *_pipe, 850 unsigned start_slot, 851 unsigned num_scissors, 852 const struct pipe_scissor_state *states) 853 { 854 struct trace_context *tr_ctx = trace_context(_pipe); 855 struct pipe_context *pipe = tr_ctx->pipe; 856 857 trace_dump_call_begin("pipe_context", "set_scissor_states"); 858 859 trace_dump_arg(ptr, pipe); 860 trace_dump_arg(uint, start_slot); 861 trace_dump_arg(uint, num_scissors); 862 trace_dump_arg(scissor_state, states); 863 864 pipe->set_scissor_states(pipe, start_slot, num_scissors, states); 865 866 trace_dump_call_end(); 867 } 868 869 870 static void 871 trace_context_set_viewport_states(struct pipe_context *_pipe, 872 unsigned start_slot, 873 unsigned num_viewports, 874 const struct pipe_viewport_state *states) 875 { 876 struct trace_context *tr_ctx = trace_context(_pipe); 877 struct pipe_context *pipe = tr_ctx->pipe; 878 879 trace_dump_call_begin("pipe_context", "set_viewport_states"); 880 881 trace_dump_arg(ptr, pipe); 882 trace_dump_arg(uint, start_slot); 883 trace_dump_arg(uint, num_viewports); 884 trace_dump_arg(viewport_state, states); 885 886 pipe->set_viewport_states(pipe, start_slot, num_viewports, states); 887 888 trace_dump_call_end(); 889 } 890 891 892 static struct pipe_sampler_view * 893 trace_context_create_sampler_view(struct pipe_context *_pipe, 894 struct pipe_resource *_resource, 895 const struct pipe_sampler_view *templ) 896 { 897 struct trace_context *tr_ctx = trace_context(_pipe); 898 struct trace_resource *tr_res = trace_resource(_resource); 899 struct pipe_context *pipe = tr_ctx->pipe; 900 struct pipe_resource *resource = tr_res->resource; 901 struct pipe_sampler_view *result; 902 struct trace_sampler_view *tr_view; 903 904 trace_dump_call_begin("pipe_context", "create_sampler_view"); 905 906 trace_dump_arg(ptr, pipe); 907 trace_dump_arg(ptr, resource); 908 909 trace_dump_arg_begin("templ"); 910 trace_dump_sampler_view_template(templ, resource->target); 911 trace_dump_arg_end(); 912 913 result = pipe->create_sampler_view(pipe, resource, templ); 914 915 trace_dump_ret(ptr, result); 916 917 trace_dump_call_end(); 918 919 /* 920 * Wrap pipe_sampler_view 921 */ 922 tr_view = CALLOC_STRUCT(trace_sampler_view); 923 tr_view->base = *templ; 924 tr_view->base.reference.count = 1; 925 tr_view->base.texture = NULL; 926 pipe_resource_reference(&tr_view->base.texture, _resource); 927 tr_view->base.context = _pipe; 928 tr_view->sampler_view = result; 929 result = &tr_view->base; 930 931 return result; 932 } 933 934 935 static void 936 trace_context_sampler_view_destroy(struct pipe_context *_pipe, 937 struct pipe_sampler_view *_view) 938 { 939 struct trace_context *tr_ctx = trace_context(_pipe); 940 struct trace_sampler_view *tr_view = trace_sampler_view(_view); 941 struct pipe_context *pipe = tr_ctx->pipe; 942 struct pipe_sampler_view *view = tr_view->sampler_view; 943 944 assert(_view->context == _pipe); 945 946 trace_dump_call_begin("pipe_context", "sampler_view_destroy"); 947 948 trace_dump_arg(ptr, pipe); 949 trace_dump_arg(ptr, view); 950 951 pipe_sampler_view_reference(&tr_view->sampler_view, NULL); 952 953 trace_dump_call_end(); 954 955 pipe_resource_reference(&_view->texture, NULL); 956 FREE(_view); 957 } 958 959 /******************************************************************** 960 * surface 961 */ 962 963 964 static struct pipe_surface * 965 trace_context_create_surface(struct pipe_context *_pipe, 966 struct pipe_resource *_resource, 967 const struct pipe_surface *surf_tmpl) 968 { 969 struct trace_context *tr_ctx = trace_context(_pipe); 970 struct trace_resource *tr_res = trace_resource(_resource); 971 struct pipe_context *pipe = tr_ctx->pipe; 972 struct pipe_resource *resource = tr_res->resource; 973 struct pipe_surface *result = NULL; 974 975 trace_dump_call_begin("pipe_context", "create_surface"); 976 977 trace_dump_arg(ptr, pipe); 978 trace_dump_arg(ptr, resource); 979 980 trace_dump_arg_begin("surf_tmpl"); 981 trace_dump_surface_template(surf_tmpl, resource->target); 982 trace_dump_arg_end(); 983 984 985 result = pipe->create_surface(pipe, resource, surf_tmpl); 986 987 trace_dump_ret(ptr, result); 988 989 trace_dump_call_end(); 990 991 result = trace_surf_create(tr_ctx, tr_res, result); 992 993 return result; 994 } 995 996 997 static void 998 trace_context_surface_destroy(struct pipe_context *_pipe, 999 struct pipe_surface *_surface) 1000 { 1001 struct trace_context *tr_ctx = trace_context(_pipe); 1002 struct pipe_context *pipe = tr_ctx->pipe; 1003 struct trace_surface *tr_surf = trace_surface(_surface); 1004 struct pipe_surface *surface = tr_surf->surface; 1005 1006 trace_dump_call_begin("pipe_context", "surface_destroy"); 1007 1008 trace_dump_arg(ptr, pipe); 1009 trace_dump_arg(ptr, surface); 1010 1011 trace_dump_call_end(); 1012 1013 trace_surf_destroy(tr_surf); 1014 } 1015 1016 1017 static void 1018 trace_context_set_sampler_views(struct pipe_context *_pipe, 1019 enum pipe_shader_type shader, 1020 unsigned start, 1021 unsigned num, 1022 struct pipe_sampler_view **views) 1023 { 1024 struct trace_context *tr_ctx = trace_context(_pipe); 1025 struct trace_sampler_view *tr_view; 1026 struct pipe_context *pipe = tr_ctx->pipe; 1027 struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SHADER_SAMPLER_VIEWS]; 1028 unsigned i; 1029 1030 /* remove this when we have pipe->set_sampler_views(..., start, ...) */ 1031 assert(start == 0); 1032 1033 for (i = 0; i < num; ++i) { 1034 tr_view = trace_sampler_view(views[i]); 1035 unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL; 1036 } 1037 views = unwrapped_views; 1038 1039 trace_dump_call_begin("pipe_context", "set_sampler_views"); 1040 1041 trace_dump_arg(ptr, pipe); 1042 trace_dump_arg(uint, shader); 1043 trace_dump_arg(uint, start); 1044 trace_dump_arg(uint, num); 1045 trace_dump_arg_array(ptr, views, num); 1046 1047 pipe->set_sampler_views(pipe, shader, start, num, views); 1048 1049 trace_dump_call_end(); 1050 } 1051 1052 1053 static void 1054 trace_context_set_vertex_buffers(struct pipe_context *_pipe, 1055 unsigned start_slot, unsigned num_buffers, 1056 const struct pipe_vertex_buffer *buffers) 1057 { 1058 struct trace_context *tr_ctx = trace_context(_pipe); 1059 struct pipe_context *pipe = tr_ctx->pipe; 1060 unsigned i; 1061 1062 trace_dump_call_begin("pipe_context", "set_vertex_buffers"); 1063 1064 trace_dump_arg(ptr, pipe); 1065 trace_dump_arg(uint, start_slot); 1066 trace_dump_arg(uint, num_buffers); 1067 1068 trace_dump_arg_begin("buffers"); 1069 trace_dump_struct_array(vertex_buffer, buffers, num_buffers); 1070 trace_dump_arg_end(); 1071 1072 if (buffers) { 1073 struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers)); 1074 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers)); 1075 for (i = 0; i < num_buffers; i++) 1076 _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer); 1077 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers); 1078 FREE(_buffers); 1079 } else { 1080 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL); 1081 } 1082 1083 trace_dump_call_end(); 1084 } 1085 1086 1087 static void 1088 trace_context_set_index_buffer(struct pipe_context *_pipe, 1089 const struct pipe_index_buffer *ib) 1090 { 1091 struct trace_context *tr_ctx = trace_context(_pipe); 1092 struct pipe_context *pipe = tr_ctx->pipe; 1093 1094 trace_dump_call_begin("pipe_context", "set_index_buffer"); 1095 1096 trace_dump_arg(ptr, pipe); 1097 trace_dump_arg(index_buffer, ib); 1098 1099 if (ib) { 1100 struct pipe_index_buffer _ib; 1101 _ib = *ib; 1102 _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer); 1103 pipe->set_index_buffer(pipe, &_ib); 1104 } else { 1105 pipe->set_index_buffer(pipe, NULL); 1106 } 1107 1108 trace_dump_call_end(); 1109 } 1110 1111 1112 static struct pipe_stream_output_target * 1113 trace_context_create_stream_output_target(struct pipe_context *_pipe, 1114 struct pipe_resource *res, 1115 unsigned buffer_offset, 1116 unsigned buffer_size) 1117 { 1118 struct trace_context *tr_ctx = trace_context(_pipe); 1119 struct pipe_context *pipe = tr_ctx->pipe; 1120 struct pipe_stream_output_target *result; 1121 1122 res = trace_resource_unwrap(tr_ctx, res); 1123 1124 trace_dump_call_begin("pipe_context", "create_stream_output_target"); 1125 1126 trace_dump_arg(ptr, pipe); 1127 trace_dump_arg(ptr, res); 1128 trace_dump_arg(uint, buffer_offset); 1129 trace_dump_arg(uint, buffer_size); 1130 1131 result = pipe->create_stream_output_target(pipe, 1132 res, buffer_offset, buffer_size); 1133 1134 trace_dump_ret(ptr, result); 1135 1136 trace_dump_call_end(); 1137 1138 return result; 1139 } 1140 1141 1142 static void 1143 trace_context_stream_output_target_destroy( 1144 struct pipe_context *_pipe, 1145 struct pipe_stream_output_target *target) 1146 { 1147 struct trace_context *tr_ctx = trace_context(_pipe); 1148 struct pipe_context *pipe = tr_ctx->pipe; 1149 1150 trace_dump_call_begin("pipe_context", "stream_output_target_destroy"); 1151 1152 trace_dump_arg(ptr, pipe); 1153 trace_dump_arg(ptr, target); 1154 1155 pipe->stream_output_target_destroy(pipe, target); 1156 1157 trace_dump_call_end(); 1158 } 1159 1160 1161 static void 1162 trace_context_set_stream_output_targets(struct pipe_context *_pipe, 1163 unsigned num_targets, 1164 struct pipe_stream_output_target **tgs, 1165 const unsigned *offsets) 1166 { 1167 struct trace_context *tr_ctx = trace_context(_pipe); 1168 struct pipe_context *pipe = tr_ctx->pipe; 1169 1170 trace_dump_call_begin("pipe_context", "set_stream_output_targets"); 1171 1172 trace_dump_arg(ptr, pipe); 1173 trace_dump_arg(uint, num_targets); 1174 trace_dump_arg_array(ptr, tgs, num_targets); 1175 trace_dump_arg_array(uint, offsets, num_targets); 1176 1177 pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets); 1178 1179 trace_dump_call_end(); 1180 } 1181 1182 1183 static void 1184 trace_context_resource_copy_region(struct pipe_context *_pipe, 1185 struct pipe_resource *dst, 1186 unsigned dst_level, 1187 unsigned dstx, unsigned dsty, unsigned dstz, 1188 struct pipe_resource *src, 1189 unsigned src_level, 1190 const struct pipe_box *src_box) 1191 { 1192 struct trace_context *tr_ctx = trace_context(_pipe); 1193 struct pipe_context *pipe = tr_ctx->pipe; 1194 1195 dst = trace_resource_unwrap(tr_ctx, dst); 1196 src = trace_resource_unwrap(tr_ctx, src); 1197 1198 trace_dump_call_begin("pipe_context", "resource_copy_region"); 1199 1200 trace_dump_arg(ptr, pipe); 1201 trace_dump_arg(ptr, dst); 1202 trace_dump_arg(uint, dst_level); 1203 trace_dump_arg(uint, dstx); 1204 trace_dump_arg(uint, dsty); 1205 trace_dump_arg(uint, dstz); 1206 trace_dump_arg(ptr, src); 1207 trace_dump_arg(uint, src_level); 1208 trace_dump_arg(box, src_box); 1209 1210 pipe->resource_copy_region(pipe, 1211 dst, dst_level, dstx, dsty, dstz, 1212 src, src_level, src_box); 1213 1214 trace_dump_call_end(); 1215 } 1216 1217 1218 static void 1219 trace_context_blit(struct pipe_context *_pipe, 1220 const struct pipe_blit_info *_info) 1221 { 1222 struct trace_context *tr_ctx = trace_context(_pipe); 1223 struct pipe_context *pipe = tr_ctx->pipe; 1224 struct pipe_blit_info info = *_info; 1225 1226 info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource); 1227 info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource); 1228 1229 trace_dump_call_begin("pipe_context", "blit"); 1230 1231 trace_dump_arg(ptr, pipe); 1232 trace_dump_arg(blit_info, _info); 1233 1234 pipe->blit(pipe, &info); 1235 1236 trace_dump_call_end(); 1237 } 1238 1239 1240 static void 1241 trace_context_flush_resource(struct pipe_context *_pipe, 1242 struct pipe_resource *resource) 1243 { 1244 struct trace_context *tr_ctx = trace_context(_pipe); 1245 struct pipe_context *pipe = tr_ctx->pipe; 1246 1247 resource = trace_resource_unwrap(tr_ctx, resource); 1248 1249 trace_dump_call_begin("pipe_context", "flush_resource"); 1250 1251 trace_dump_arg(ptr, pipe); 1252 trace_dump_arg(ptr, resource); 1253 1254 pipe->flush_resource(pipe, resource); 1255 1256 trace_dump_call_end(); 1257 } 1258 1259 1260 static void 1261 trace_context_clear(struct pipe_context *_pipe, 1262 unsigned buffers, 1263 const union pipe_color_union *color, 1264 double depth, 1265 unsigned stencil) 1266 { 1267 struct trace_context *tr_ctx = trace_context(_pipe); 1268 struct pipe_context *pipe = tr_ctx->pipe; 1269 1270 trace_dump_call_begin("pipe_context", "clear"); 1271 1272 trace_dump_arg(ptr, pipe); 1273 trace_dump_arg(uint, buffers); 1274 trace_dump_arg_begin("color"); 1275 if (color) 1276 trace_dump_array(float, color->f, 4); 1277 else 1278 trace_dump_null(); 1279 trace_dump_arg_end(); 1280 trace_dump_arg(float, depth); 1281 trace_dump_arg(uint, stencil); 1282 1283 pipe->clear(pipe, buffers, color, depth, stencil); 1284 1285 trace_dump_call_end(); 1286 } 1287 1288 1289 static void 1290 trace_context_clear_render_target(struct pipe_context *_pipe, 1291 struct pipe_surface *dst, 1292 const union pipe_color_union *color, 1293 unsigned dstx, unsigned dsty, 1294 unsigned width, unsigned height, 1295 bool render_condition_enabled) 1296 { 1297 struct trace_context *tr_ctx = trace_context(_pipe); 1298 struct pipe_context *pipe = tr_ctx->pipe; 1299 1300 dst = trace_surface_unwrap(tr_ctx, dst); 1301 1302 trace_dump_call_begin("pipe_context", "clear_render_target"); 1303 1304 trace_dump_arg(ptr, pipe); 1305 trace_dump_arg(ptr, dst); 1306 trace_dump_arg_array(float, color->f, 4); 1307 trace_dump_arg(uint, dstx); 1308 trace_dump_arg(uint, dsty); 1309 trace_dump_arg(uint, width); 1310 trace_dump_arg(uint, height); 1311 trace_dump_arg(bool, render_condition_enabled); 1312 1313 pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height, 1314 render_condition_enabled); 1315 1316 trace_dump_call_end(); 1317 } 1318 1319 static void 1320 trace_context_clear_depth_stencil(struct pipe_context *_pipe, 1321 struct pipe_surface *dst, 1322 unsigned clear_flags, 1323 double depth, 1324 unsigned stencil, 1325 unsigned dstx, unsigned dsty, 1326 unsigned width, unsigned height, 1327 bool render_condition_enabled) 1328 { 1329 struct trace_context *tr_ctx = trace_context(_pipe); 1330 struct pipe_context *pipe = tr_ctx->pipe; 1331 1332 dst = trace_surface_unwrap(tr_ctx, dst); 1333 1334 trace_dump_call_begin("pipe_context", "clear_depth_stencil"); 1335 1336 trace_dump_arg(ptr, pipe); 1337 trace_dump_arg(ptr, dst); 1338 trace_dump_arg(uint, clear_flags); 1339 trace_dump_arg(float, depth); 1340 trace_dump_arg(uint, stencil); 1341 trace_dump_arg(uint, dstx); 1342 trace_dump_arg(uint, dsty); 1343 trace_dump_arg(uint, width); 1344 trace_dump_arg(uint, height); 1345 trace_dump_arg(bool, render_condition_enabled); 1346 1347 pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil, 1348 dstx, dsty, width, height, 1349 render_condition_enabled); 1350 1351 trace_dump_call_end(); 1352 } 1353 1354 static inline void 1355 trace_context_clear_texture(struct pipe_context *_pipe, 1356 struct pipe_resource *res, 1357 unsigned level, 1358 const struct pipe_box *box, 1359 const void *data) 1360 { 1361 struct trace_context *tr_ctx = trace_context(_pipe); 1362 struct pipe_context *pipe = tr_ctx->pipe; 1363 1364 res = trace_resource_unwrap(tr_ctx, res); 1365 1366 trace_dump_call_begin("pipe_context", "clear_texture"); 1367 1368 trace_dump_arg(ptr, pipe); 1369 trace_dump_arg(ptr, res); 1370 trace_dump_arg(uint, level); 1371 trace_dump_arg_begin("box"); 1372 trace_dump_box(box); 1373 trace_dump_arg_end(); 1374 trace_dump_arg(ptr, data); 1375 1376 pipe->clear_texture(pipe, res, level, box, data); 1377 1378 trace_dump_call_end(); 1379 } 1380 1381 static void 1382 trace_context_flush(struct pipe_context *_pipe, 1383 struct pipe_fence_handle **fence, 1384 unsigned flags) 1385 { 1386 struct trace_context *tr_ctx = trace_context(_pipe); 1387 struct pipe_context *pipe = tr_ctx->pipe; 1388 1389 trace_dump_call_begin("pipe_context", "flush"); 1390 1391 trace_dump_arg(ptr, pipe); 1392 trace_dump_arg(uint, flags); 1393 1394 pipe->flush(pipe, fence, flags); 1395 1396 if (fence) 1397 trace_dump_ret(ptr, *fence); 1398 1399 trace_dump_call_end(); 1400 } 1401 1402 1403 static inline boolean 1404 trace_context_generate_mipmap(struct pipe_context *_pipe, 1405 struct pipe_resource *res, 1406 enum pipe_format format, 1407 unsigned base_level, 1408 unsigned last_level, 1409 unsigned first_layer, 1410 unsigned last_layer) 1411 { 1412 struct trace_context *tr_ctx = trace_context(_pipe); 1413 struct pipe_context *pipe = tr_ctx->pipe; 1414 boolean ret; 1415 1416 res = trace_resource_unwrap(tr_ctx, res); 1417 1418 trace_dump_call_begin("pipe_context", "generate_mipmap"); 1419 1420 trace_dump_arg(ptr, pipe); 1421 trace_dump_arg(ptr, res); 1422 1423 trace_dump_arg(format, format); 1424 trace_dump_arg(uint, base_level); 1425 trace_dump_arg(uint, last_level); 1426 trace_dump_arg(uint, first_layer); 1427 trace_dump_arg(uint, last_layer); 1428 1429 ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level, 1430 first_layer, last_layer); 1431 1432 trace_dump_ret(bool, ret); 1433 trace_dump_call_end(); 1434 1435 return ret; 1436 } 1437 1438 1439 static void 1440 trace_context_destroy(struct pipe_context *_pipe) 1441 { 1442 struct trace_context *tr_ctx = trace_context(_pipe); 1443 struct pipe_context *pipe = tr_ctx->pipe; 1444 1445 trace_dump_call_begin("pipe_context", "destroy"); 1446 trace_dump_arg(ptr, pipe); 1447 trace_dump_call_end(); 1448 1449 pipe->destroy(pipe); 1450 1451 FREE(tr_ctx); 1452 } 1453 1454 1455 /******************************************************************** 1456 * transfer 1457 */ 1458 1459 1460 static void * 1461 trace_context_transfer_map(struct pipe_context *_context, 1462 struct pipe_resource *_resource, 1463 unsigned level, 1464 unsigned usage, 1465 const struct pipe_box *box, 1466 struct pipe_transfer **transfer) 1467 { 1468 struct trace_context *tr_context = trace_context(_context); 1469 struct trace_resource *tr_res = trace_resource(_resource); 1470 struct pipe_context *context = tr_context->pipe; 1471 struct pipe_resource *texture = tr_res->resource; 1472 struct pipe_transfer *result = NULL; 1473 void *map; 1474 1475 assert(texture->screen == context->screen); 1476 1477 /* 1478 * Map and transfers can't be serialized so we convert all write transfers 1479 * to texture/buffer_subdata and ignore read transfers. 1480 */ 1481 1482 map = context->transfer_map(context, texture, level, usage, box, &result); 1483 if (!map) 1484 return NULL; 1485 1486 *transfer = trace_transfer_create(tr_context, tr_res, result); 1487 1488 if (map) { 1489 if (usage & PIPE_TRANSFER_WRITE) { 1490 trace_transfer(*transfer)->map = map; 1491 } 1492 } 1493 1494 return *transfer ? map : NULL; 1495 } 1496 1497 static void 1498 trace_context_transfer_flush_region( struct pipe_context *_context, 1499 struct pipe_transfer *_transfer, 1500 const struct pipe_box *box) 1501 { 1502 struct trace_context *tr_context = trace_context(_context); 1503 struct trace_transfer *tr_transfer = trace_transfer(_transfer); 1504 struct pipe_context *context = tr_context->pipe; 1505 struct pipe_transfer *transfer = tr_transfer->transfer; 1506 1507 context->transfer_flush_region(context, transfer, box); 1508 } 1509 1510 static void 1511 trace_context_transfer_unmap(struct pipe_context *_context, 1512 struct pipe_transfer *_transfer) 1513 { 1514 struct trace_context *tr_ctx = trace_context(_context); 1515 struct trace_transfer *tr_trans = trace_transfer(_transfer); 1516 struct pipe_context *context = tr_ctx->pipe; 1517 struct pipe_transfer *transfer = tr_trans->transfer; 1518 1519 if (tr_trans->map) { 1520 /* 1521 * Fake a texture/buffer_subdata 1522 */ 1523 1524 struct pipe_resource *resource = transfer->resource; 1525 unsigned level = transfer->level; 1526 unsigned usage = transfer->usage; 1527 const struct pipe_box *box = &transfer->box; 1528 unsigned stride = transfer->stride; 1529 unsigned layer_stride = transfer->layer_stride; 1530 1531 if (resource->target == PIPE_BUFFER) 1532 trace_dump_call_begin("pipe_context", "buffer_subdata"); 1533 else 1534 trace_dump_call_begin("pipe_context", "texture_subdata"); 1535 1536 trace_dump_arg(ptr, context); 1537 trace_dump_arg(ptr, resource); 1538 trace_dump_arg(uint, level); 1539 trace_dump_arg(uint, usage); 1540 trace_dump_arg(box, box); 1541 1542 trace_dump_arg_begin("data"); 1543 trace_dump_box_bytes(tr_trans->map, 1544 resource, 1545 box, 1546 stride, 1547 layer_stride); 1548 trace_dump_arg_end(); 1549 1550 trace_dump_arg(uint, stride); 1551 trace_dump_arg(uint, layer_stride); 1552 1553 trace_dump_call_end(); 1554 1555 tr_trans->map = NULL; 1556 } 1557 1558 context->transfer_unmap(context, transfer); 1559 trace_transfer_destroy(tr_ctx, tr_trans); 1560 } 1561 1562 1563 static void 1564 trace_context_buffer_subdata(struct pipe_context *_context, 1565 struct pipe_resource *_resource, 1566 unsigned usage, unsigned offset, 1567 unsigned size, const void *data) 1568 { 1569 struct trace_context *tr_context = trace_context(_context); 1570 struct trace_resource *tr_res = trace_resource(_resource); 1571 struct pipe_context *context = tr_context->pipe; 1572 struct pipe_resource *resource = tr_res->resource; 1573 struct pipe_box box; 1574 1575 assert(resource->screen == context->screen); 1576 1577 trace_dump_call_begin("pipe_context", "buffer_subdata"); 1578 1579 trace_dump_arg(ptr, context); 1580 trace_dump_arg(ptr, resource); 1581 trace_dump_arg(uint, usage); 1582 trace_dump_arg(uint, offset); 1583 trace_dump_arg(uint, size); 1584 1585 trace_dump_arg_begin("data"); 1586 u_box_1d(offset, size, &box); 1587 trace_dump_box_bytes(data, resource, &box, 0, 0); 1588 trace_dump_arg_end(); 1589 1590 trace_dump_call_end(); 1591 1592 context->buffer_subdata(context, resource, usage, offset, size, data); 1593 } 1594 1595 1596 static void 1597 trace_context_texture_subdata(struct pipe_context *_context, 1598 struct pipe_resource *_resource, 1599 unsigned level, 1600 unsigned usage, 1601 const struct pipe_box *box, 1602 const void *data, 1603 unsigned stride, 1604 unsigned layer_stride) 1605 { 1606 struct trace_context *tr_context = trace_context(_context); 1607 struct trace_resource *tr_res = trace_resource(_resource); 1608 struct pipe_context *context = tr_context->pipe; 1609 struct pipe_resource *resource = tr_res->resource; 1610 1611 assert(resource->screen == context->screen); 1612 1613 trace_dump_call_begin("pipe_context", "texture_subdata"); 1614 1615 trace_dump_arg(ptr, context); 1616 trace_dump_arg(ptr, resource); 1617 trace_dump_arg(uint, level); 1618 trace_dump_arg(uint, usage); 1619 trace_dump_arg(box, box); 1620 1621 trace_dump_arg_begin("data"); 1622 trace_dump_box_bytes(data, 1623 resource, 1624 box, 1625 stride, 1626 layer_stride); 1627 trace_dump_arg_end(); 1628 1629 trace_dump_arg(uint, stride); 1630 trace_dump_arg(uint, layer_stride); 1631 1632 trace_dump_call_end(); 1633 1634 context->texture_subdata(context, resource, level, usage, box, 1635 data, stride, layer_stride); 1636 } 1637 1638 static void 1639 trace_context_invalidate_resource(struct pipe_context *_context, 1640 struct pipe_resource *_resource) 1641 { 1642 struct trace_context *tr_context = trace_context(_context); 1643 struct trace_resource *tr_res = trace_resource(_resource); 1644 struct pipe_context *context = tr_context->pipe; 1645 struct pipe_resource *resource = tr_res->resource; 1646 1647 assert(resource->screen == context->screen); 1648 1649 trace_dump_call_begin("pipe_context", "invalidate_resource"); 1650 1651 trace_dump_arg(ptr, context); 1652 trace_dump_arg(ptr, resource); 1653 1654 trace_dump_call_end(); 1655 1656 context->invalidate_resource(context, resource); 1657 } 1658 1659 static void 1660 trace_context_render_condition(struct pipe_context *_context, 1661 struct pipe_query *query, 1662 boolean condition, 1663 uint mode) 1664 { 1665 struct trace_context *tr_context = trace_context(_context); 1666 struct pipe_context *context = tr_context->pipe; 1667 1668 query = trace_query_unwrap(query); 1669 1670 trace_dump_call_begin("pipe_context", "render_condition"); 1671 1672 trace_dump_arg(ptr, context); 1673 trace_dump_arg(ptr, query); 1674 trace_dump_arg(bool, condition); 1675 trace_dump_arg(uint, mode); 1676 1677 trace_dump_call_end(); 1678 1679 context->render_condition(context, query, condition, mode); 1680 } 1681 1682 1683 static void 1684 trace_context_texture_barrier(struct pipe_context *_context, unsigned flags) 1685 { 1686 struct trace_context *tr_context = trace_context(_context); 1687 struct pipe_context *context = tr_context->pipe; 1688 1689 trace_dump_call_begin("pipe_context", "texture_barrier"); 1690 1691 trace_dump_arg(ptr, context); 1692 trace_dump_arg(uint, flags); 1693 1694 trace_dump_call_end(); 1695 1696 context->texture_barrier(context, flags); 1697 } 1698 1699 1700 static void 1701 trace_context_memory_barrier(struct pipe_context *_context, 1702 unsigned flags) 1703 { 1704 struct trace_context *tr_context = trace_context(_context); 1705 struct pipe_context *context = tr_context->pipe; 1706 1707 trace_dump_call_begin("pipe_context", "memory_barrier"); 1708 trace_dump_arg(ptr, context); 1709 trace_dump_arg(uint, flags); 1710 trace_dump_call_end(); 1711 1712 context->memory_barrier(context, flags); 1713 } 1714 1715 1716 static void 1717 trace_context_set_tess_state(struct pipe_context *_context, 1718 const float default_outer_level[4], 1719 const float default_inner_level[2]) 1720 { 1721 struct trace_context *tr_context = trace_context(_context); 1722 struct pipe_context *context = tr_context->pipe; 1723 1724 trace_dump_call_begin("pipe_context", "set_tess_state"); 1725 trace_dump_arg(ptr, context); 1726 trace_dump_arg_array(float, default_outer_level, 4); 1727 trace_dump_arg_array(float, default_inner_level, 2); 1728 trace_dump_call_end(); 1729 1730 context->set_tess_state(context, default_outer_level, default_inner_level); 1731 } 1732 1733 1734 static void trace_context_set_shader_buffers(struct pipe_context *_context, 1735 enum pipe_shader_type shader, 1736 unsigned start, unsigned nr, 1737 const struct pipe_shader_buffer *buffers) 1738 { 1739 struct trace_context *tr_context = trace_context(_context); 1740 struct pipe_context *context = tr_context->pipe; 1741 struct pipe_shader_buffer *_buffers = NULL; 1742 1743 trace_dump_call_begin("pipe_context", "set_shader_buffers"); 1744 trace_dump_arg(ptr, context); 1745 trace_dump_arg(uint, shader); 1746 trace_dump_arg(uint, start); 1747 trace_dump_arg_begin("buffers"); 1748 trace_dump_struct_array(shader_buffer, buffers, nr); 1749 trace_dump_arg_end(); 1750 trace_dump_call_end(); 1751 1752 if (buffers) { 1753 int i; 1754 1755 _buffers = MALLOC(nr * sizeof(struct pipe_shader_buffer)); 1756 if (!_buffers) 1757 return; 1758 1759 for (i = 0; i < nr; i++) { 1760 _buffers[i] = buffers[i]; 1761 _buffers[i].buffer = trace_resource_unwrap( 1762 tr_context, _buffers[i].buffer); 1763 } 1764 } 1765 1766 context->set_shader_buffers(context, shader, start, nr, _buffers); 1767 1768 if (_buffers) 1769 FREE(_buffers); 1770 } 1771 1772 static void trace_context_set_shader_images(struct pipe_context *_context, 1773 enum pipe_shader_type shader, 1774 unsigned start, unsigned nr, 1775 const struct pipe_image_view *images) 1776 { 1777 struct trace_context *tr_context = trace_context(_context); 1778 struct pipe_context *context = tr_context->pipe; 1779 struct pipe_image_view *_images = NULL; 1780 1781 trace_dump_call_begin("pipe_context", "set_shader_images"); 1782 trace_dump_arg(ptr, context); 1783 trace_dump_arg(uint, shader); 1784 trace_dump_arg(uint, start); 1785 trace_dump_arg_begin("images"); 1786 trace_dump_struct_array(image_view, images, nr); 1787 trace_dump_arg_end(); 1788 trace_dump_call_end(); 1789 1790 if (images) { 1791 int i; 1792 1793 _images = MALLOC(nr * sizeof(struct pipe_image_view)); 1794 if (!_images) 1795 return; 1796 1797 for (i = 0; i < nr; i++) { 1798 _images[i] = images[i]; 1799 _images[i].resource = trace_resource_unwrap(tr_context, 1800 _images[i].resource); 1801 } 1802 } 1803 1804 context->set_shader_images(context, shader, start, nr, _images); 1805 1806 if (_images) 1807 FREE(_images); 1808 } 1809 1810 static void trace_context_launch_grid(struct pipe_context *_pipe, 1811 const struct pipe_grid_info *info) 1812 { 1813 struct trace_context *tr_ctx = trace_context(_pipe); 1814 struct pipe_context *pipe = tr_ctx->pipe; 1815 1816 trace_dump_call_begin("pipe_context", "launch_grid"); 1817 1818 trace_dump_arg(ptr, pipe); 1819 trace_dump_arg(grid_info, info); 1820 1821 trace_dump_trace_flush(); 1822 1823 if (info->indirect) { 1824 struct pipe_grid_info _info; 1825 1826 memcpy(&_info, info, sizeof(_info)); 1827 _info.indirect = trace_resource_unwrap(tr_ctx, _info.indirect); 1828 pipe->launch_grid(pipe, &_info); 1829 } else { 1830 pipe->launch_grid(pipe, info); 1831 } 1832 1833 trace_dump_call_end(); 1834 } 1835 1836 struct pipe_context * 1837 trace_context_create(struct trace_screen *tr_scr, 1838 struct pipe_context *pipe) 1839 { 1840 struct trace_context *tr_ctx; 1841 1842 if (!pipe) 1843 goto error1; 1844 1845 if (!trace_enabled()) 1846 goto error1; 1847 1848 tr_ctx = CALLOC_STRUCT(trace_context); 1849 if (!tr_ctx) 1850 goto error1; 1851 1852 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */ 1853 tr_ctx->base.screen = &tr_scr->base; 1854 1855 tr_ctx->base.destroy = trace_context_destroy; 1856 1857 #define TR_CTX_INIT(_member) \ 1858 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL 1859 1860 TR_CTX_INIT(draw_vbo); 1861 TR_CTX_INIT(render_condition); 1862 TR_CTX_INIT(create_query); 1863 TR_CTX_INIT(destroy_query); 1864 TR_CTX_INIT(begin_query); 1865 TR_CTX_INIT(end_query); 1866 TR_CTX_INIT(get_query_result); 1867 TR_CTX_INIT(set_active_query_state); 1868 TR_CTX_INIT(create_blend_state); 1869 TR_CTX_INIT(bind_blend_state); 1870 TR_CTX_INIT(delete_blend_state); 1871 TR_CTX_INIT(create_sampler_state); 1872 TR_CTX_INIT(bind_sampler_states); 1873 TR_CTX_INIT(delete_sampler_state); 1874 TR_CTX_INIT(create_rasterizer_state); 1875 TR_CTX_INIT(bind_rasterizer_state); 1876 TR_CTX_INIT(delete_rasterizer_state); 1877 TR_CTX_INIT(create_depth_stencil_alpha_state); 1878 TR_CTX_INIT(bind_depth_stencil_alpha_state); 1879 TR_CTX_INIT(delete_depth_stencil_alpha_state); 1880 TR_CTX_INIT(create_fs_state); 1881 TR_CTX_INIT(bind_fs_state); 1882 TR_CTX_INIT(delete_fs_state); 1883 TR_CTX_INIT(create_vs_state); 1884 TR_CTX_INIT(bind_vs_state); 1885 TR_CTX_INIT(delete_vs_state); 1886 TR_CTX_INIT(create_gs_state); 1887 TR_CTX_INIT(bind_gs_state); 1888 TR_CTX_INIT(delete_gs_state); 1889 TR_CTX_INIT(create_tcs_state); 1890 TR_CTX_INIT(bind_tcs_state); 1891 TR_CTX_INIT(delete_tcs_state); 1892 TR_CTX_INIT(create_tes_state); 1893 TR_CTX_INIT(bind_tes_state); 1894 TR_CTX_INIT(delete_tes_state); 1895 TR_CTX_INIT(create_compute_state); 1896 TR_CTX_INIT(bind_compute_state); 1897 TR_CTX_INIT(delete_compute_state); 1898 TR_CTX_INIT(create_vertex_elements_state); 1899 TR_CTX_INIT(bind_vertex_elements_state); 1900 TR_CTX_INIT(delete_vertex_elements_state); 1901 TR_CTX_INIT(set_blend_color); 1902 TR_CTX_INIT(set_stencil_ref); 1903 TR_CTX_INIT(set_clip_state); 1904 TR_CTX_INIT(set_sample_mask); 1905 TR_CTX_INIT(set_constant_buffer); 1906 TR_CTX_INIT(set_framebuffer_state); 1907 TR_CTX_INIT(set_polygon_stipple); 1908 TR_CTX_INIT(set_scissor_states); 1909 TR_CTX_INIT(set_viewport_states); 1910 TR_CTX_INIT(set_sampler_views); 1911 TR_CTX_INIT(create_sampler_view); 1912 TR_CTX_INIT(sampler_view_destroy); 1913 TR_CTX_INIT(create_surface); 1914 TR_CTX_INIT(surface_destroy); 1915 TR_CTX_INIT(set_vertex_buffers); 1916 TR_CTX_INIT(set_index_buffer); 1917 TR_CTX_INIT(create_stream_output_target); 1918 TR_CTX_INIT(stream_output_target_destroy); 1919 TR_CTX_INIT(set_stream_output_targets); 1920 TR_CTX_INIT(resource_copy_region); 1921 TR_CTX_INIT(blit); 1922 TR_CTX_INIT(flush_resource); 1923 TR_CTX_INIT(clear); 1924 TR_CTX_INIT(clear_render_target); 1925 TR_CTX_INIT(clear_depth_stencil); 1926 TR_CTX_INIT(clear_texture); 1927 TR_CTX_INIT(flush); 1928 TR_CTX_INIT(generate_mipmap); 1929 TR_CTX_INIT(texture_barrier); 1930 TR_CTX_INIT(memory_barrier); 1931 TR_CTX_INIT(set_tess_state); 1932 TR_CTX_INIT(set_shader_buffers); 1933 TR_CTX_INIT(launch_grid); 1934 TR_CTX_INIT(set_shader_images); 1935 1936 TR_CTX_INIT(transfer_map); 1937 TR_CTX_INIT(transfer_unmap); 1938 TR_CTX_INIT(transfer_flush_region); 1939 TR_CTX_INIT(buffer_subdata); 1940 TR_CTX_INIT(texture_subdata); 1941 TR_CTX_INIT(invalidate_resource); 1942 1943 #undef TR_CTX_INIT 1944 1945 tr_ctx->pipe = pipe; 1946 1947 return &tr_ctx->base; 1948 1949 error1: 1950 return pipe; 1951 } 1952 1953 1954 /** 1955 * Sanity checker: check that the given context really is a 1956 * trace context (and not the wrapped driver's context). 1957 */ 1958 void 1959 trace_context_check(const struct pipe_context *pipe) 1960 { 1961 MAYBE_UNUSED struct trace_context *tr_ctx = (struct trace_context *) pipe; 1962 assert(tr_ctx->base.destroy == trace_context_destroy); 1963 } 1964
