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