tr_context.c revision e4d8084cbdeaaa392969d077e2a9d8e9df3b2cdc
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_SHADER_SAMPLER_VIEWS]; 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 trace_dump_call_begin("pipe_context", "set_sampler_views"); 907 908 trace_dump_arg(ptr, pipe); 909 trace_dump_arg(uint, shader); 910 trace_dump_arg(uint, start); 911 trace_dump_arg(uint, num); 912 trace_dump_arg_array(ptr, views, num); 913 914 pipe->set_sampler_views(pipe, shader, start, num, views); 915 916 trace_dump_call_end(); 917} 918 919 920static INLINE void 921trace_context_set_vertex_buffers(struct pipe_context *_pipe, 922 unsigned start_slot, unsigned num_buffers, 923 const struct pipe_vertex_buffer *buffers) 924{ 925 struct trace_context *tr_ctx = trace_context(_pipe); 926 struct pipe_context *pipe = tr_ctx->pipe; 927 unsigned i; 928 929 trace_dump_call_begin("pipe_context", "set_vertex_buffers"); 930 931 trace_dump_arg(ptr, pipe); 932 trace_dump_arg(uint, start_slot); 933 trace_dump_arg(uint, num_buffers); 934 935 trace_dump_arg_begin("buffers"); 936 trace_dump_struct_array(vertex_buffer, buffers, num_buffers); 937 trace_dump_arg_end(); 938 939 if (buffers) { 940 struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers)); 941 memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers)); 942 for (i = 0; i < num_buffers; i++) 943 _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer); 944 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers); 945 FREE(_buffers); 946 } else { 947 pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL); 948 } 949 950 trace_dump_call_end(); 951} 952 953 954static INLINE void 955trace_context_set_index_buffer(struct pipe_context *_pipe, 956 const struct pipe_index_buffer *ib) 957{ 958 struct trace_context *tr_ctx = trace_context(_pipe); 959 struct pipe_context *pipe = tr_ctx->pipe; 960 961 trace_dump_call_begin("pipe_context", "set_index_buffer"); 962 963 trace_dump_arg(ptr, pipe); 964 trace_dump_arg(index_buffer, ib); 965 966 if (ib) { 967 struct pipe_index_buffer _ib; 968 _ib = *ib; 969 _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer); 970 pipe->set_index_buffer(pipe, &_ib); 971 } else { 972 pipe->set_index_buffer(pipe, NULL); 973 } 974 975 trace_dump_call_end(); 976} 977 978 979static INLINE struct pipe_stream_output_target * 980trace_context_create_stream_output_target(struct pipe_context *_pipe, 981 struct pipe_resource *res, 982 unsigned buffer_offset, 983 unsigned buffer_size) 984{ 985 struct trace_context *tr_ctx = trace_context(_pipe); 986 struct pipe_context *pipe = tr_ctx->pipe; 987 struct pipe_stream_output_target *result; 988 989 res = trace_resource_unwrap(tr_ctx, res); 990 991 trace_dump_call_begin("pipe_context", "create_stream_output_target"); 992 993 trace_dump_arg(ptr, pipe); 994 trace_dump_arg(ptr, res); 995 trace_dump_arg(uint, buffer_offset); 996 trace_dump_arg(uint, buffer_size); 997 998 result = pipe->create_stream_output_target(pipe, 999 res, buffer_offset, buffer_size); 1000 1001 trace_dump_ret(ptr, result); 1002 1003 trace_dump_call_end(); 1004 1005 return result; 1006} 1007 1008 1009static INLINE void 1010trace_context_stream_output_target_destroy( 1011 struct pipe_context *_pipe, 1012 struct pipe_stream_output_target *target) 1013{ 1014 struct trace_context *tr_ctx = trace_context(_pipe); 1015 struct pipe_context *pipe = tr_ctx->pipe; 1016 1017 trace_dump_call_begin("pipe_context", "stream_output_target_destroy"); 1018 1019 trace_dump_arg(ptr, pipe); 1020 trace_dump_arg(ptr, target); 1021 1022 pipe->stream_output_target_destroy(pipe, target); 1023 1024 trace_dump_call_end(); 1025} 1026 1027 1028static INLINE void 1029trace_context_set_stream_output_targets(struct pipe_context *_pipe, 1030 unsigned num_targets, 1031 struct pipe_stream_output_target **tgs, 1032 unsigned append_bitmask) 1033{ 1034 struct trace_context *tr_ctx = trace_context(_pipe); 1035 struct pipe_context *pipe = tr_ctx->pipe; 1036 1037 trace_dump_call_begin("pipe_context", "set_stream_output_targets"); 1038 1039 trace_dump_arg(ptr, pipe); 1040 trace_dump_arg(uint, num_targets); 1041 trace_dump_arg_array(ptr, tgs, num_targets); 1042 trace_dump_arg(uint, append_bitmask); 1043 1044 pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask); 1045 1046 trace_dump_call_end(); 1047} 1048 1049 1050static INLINE void 1051trace_context_resource_copy_region(struct pipe_context *_pipe, 1052 struct pipe_resource *dst, 1053 unsigned dst_level, 1054 unsigned dstx, unsigned dsty, unsigned dstz, 1055 struct pipe_resource *src, 1056 unsigned src_level, 1057 const struct pipe_box *src_box) 1058{ 1059 struct trace_context *tr_ctx = trace_context(_pipe); 1060 struct pipe_context *pipe = tr_ctx->pipe; 1061 1062 dst = trace_resource_unwrap(tr_ctx, dst); 1063 src = trace_resource_unwrap(tr_ctx, src); 1064 1065 trace_dump_call_begin("pipe_context", "resource_copy_region"); 1066 1067 trace_dump_arg(ptr, pipe); 1068 trace_dump_arg(ptr, dst); 1069 trace_dump_arg(uint, dst_level); 1070 trace_dump_arg(uint, dstx); 1071 trace_dump_arg(uint, dsty); 1072 trace_dump_arg(uint, dstz); 1073 trace_dump_arg(ptr, src); 1074 trace_dump_arg(uint, src_level); 1075 trace_dump_arg(box, src_box); 1076 1077 pipe->resource_copy_region(pipe, 1078 dst, dst_level, dstx, dsty, dstz, 1079 src, src_level, src_box); 1080 1081 trace_dump_call_end(); 1082} 1083 1084 1085static INLINE void 1086trace_context_blit(struct pipe_context *_pipe, 1087 const struct pipe_blit_info *_info) 1088{ 1089 struct trace_context *tr_ctx = trace_context(_pipe); 1090 struct pipe_context *pipe = tr_ctx->pipe; 1091 struct pipe_blit_info info = *_info; 1092 1093 info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource); 1094 info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource); 1095 1096 trace_dump_call_begin("pipe_context", "blit"); 1097 1098 trace_dump_arg(ptr, pipe); 1099 trace_dump_arg(blit_info, _info); 1100 1101 pipe->blit(pipe, &info); 1102 1103 trace_dump_call_end(); 1104} 1105 1106 1107static void 1108trace_context_flush_resource(struct pipe_context *_pipe, 1109 struct pipe_resource *resource) 1110{ 1111 struct trace_context *tr_ctx = trace_context(_pipe); 1112 struct pipe_context *pipe = tr_ctx->pipe; 1113 1114 resource = trace_resource_unwrap(tr_ctx, resource); 1115 1116 trace_dump_call_begin("pipe_context", "flush_resource"); 1117 1118 trace_dump_arg(ptr, pipe); 1119 trace_dump_arg(ptr, resource); 1120 1121 pipe->flush_resource(pipe, resource); 1122 1123 trace_dump_call_end(); 1124} 1125 1126 1127static INLINE void 1128trace_context_clear(struct pipe_context *_pipe, 1129 unsigned buffers, 1130 const union pipe_color_union *color, 1131 double depth, 1132 unsigned stencil) 1133{ 1134 struct trace_context *tr_ctx = trace_context(_pipe); 1135 struct pipe_context *pipe = tr_ctx->pipe; 1136 1137 trace_dump_call_begin("pipe_context", "clear"); 1138 1139 trace_dump_arg(ptr, pipe); 1140 trace_dump_arg(uint, buffers); 1141 trace_dump_arg_begin("color"); 1142 if (color) 1143 trace_dump_array(float, color->f, 4); 1144 else 1145 trace_dump_null(); 1146 trace_dump_arg_end(); 1147 trace_dump_arg(float, depth); 1148 trace_dump_arg(uint, stencil); 1149 1150 pipe->clear(pipe, buffers, color, depth, stencil); 1151 1152 trace_dump_call_end(); 1153} 1154 1155 1156static INLINE void 1157trace_context_clear_render_target(struct pipe_context *_pipe, 1158 struct pipe_surface *dst, 1159 const union pipe_color_union *color, 1160 unsigned dstx, unsigned dsty, 1161 unsigned width, unsigned height) 1162{ 1163 struct trace_context *tr_ctx = trace_context(_pipe); 1164 struct pipe_context *pipe = tr_ctx->pipe; 1165 1166 dst = trace_surface_unwrap(tr_ctx, dst); 1167 1168 trace_dump_call_begin("pipe_context", "clear_render_target"); 1169 1170 trace_dump_arg(ptr, pipe); 1171 trace_dump_arg(ptr, dst); 1172 trace_dump_arg_array(float, color->f, 4); 1173 trace_dump_arg(uint, dstx); 1174 trace_dump_arg(uint, dsty); 1175 trace_dump_arg(uint, width); 1176 trace_dump_arg(uint, height); 1177 1178 pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height); 1179 1180 trace_dump_call_end(); 1181} 1182 1183static INLINE void 1184trace_context_clear_depth_stencil(struct pipe_context *_pipe, 1185 struct pipe_surface *dst, 1186 unsigned clear_flags, 1187 double depth, 1188 unsigned stencil, 1189 unsigned dstx, unsigned dsty, 1190 unsigned width, unsigned height) 1191{ 1192 struct trace_context *tr_ctx = trace_context(_pipe); 1193 struct pipe_context *pipe = tr_ctx->pipe; 1194 1195 dst = trace_surface_unwrap(tr_ctx, dst); 1196 1197 trace_dump_call_begin("pipe_context", "clear_depth_stencil"); 1198 1199 trace_dump_arg(ptr, pipe); 1200 trace_dump_arg(ptr, dst); 1201 trace_dump_arg(uint, clear_flags); 1202 trace_dump_arg(float, depth); 1203 trace_dump_arg(uint, stencil); 1204 trace_dump_arg(uint, dstx); 1205 trace_dump_arg(uint, dsty); 1206 trace_dump_arg(uint, width); 1207 trace_dump_arg(uint, height); 1208 1209 pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil, 1210 dstx, dsty, width, height); 1211 1212 trace_dump_call_end(); 1213} 1214 1215static INLINE void 1216trace_context_flush(struct pipe_context *_pipe, 1217 struct pipe_fence_handle **fence, 1218 unsigned flags) 1219{ 1220 struct trace_context *tr_ctx = trace_context(_pipe); 1221 struct pipe_context *pipe = tr_ctx->pipe; 1222 1223 trace_dump_call_begin("pipe_context", "flush"); 1224 1225 trace_dump_arg(ptr, pipe); 1226 trace_dump_arg(uint, flags); 1227 1228 pipe->flush(pipe, fence, flags); 1229 1230 if(fence) 1231 trace_dump_ret(ptr, *fence); 1232 1233 trace_dump_call_end(); 1234} 1235 1236 1237static INLINE void 1238trace_context_destroy(struct pipe_context *_pipe) 1239{ 1240 struct trace_context *tr_ctx = trace_context(_pipe); 1241 struct pipe_context *pipe = tr_ctx->pipe; 1242 1243 trace_dump_call_begin("pipe_context", "destroy"); 1244 trace_dump_arg(ptr, pipe); 1245 trace_dump_call_end(); 1246 1247 pipe->destroy(pipe); 1248 1249 FREE(tr_ctx); 1250} 1251 1252 1253/******************************************************************** 1254 * transfer 1255 */ 1256 1257 1258static void * 1259trace_context_transfer_map(struct pipe_context *_context, 1260 struct pipe_resource *_resource, 1261 unsigned level, 1262 unsigned usage, 1263 const struct pipe_box *box, 1264 struct pipe_transfer **transfer) 1265{ 1266 struct trace_context *tr_context = trace_context(_context); 1267 struct trace_resource *tr_res = trace_resource(_resource); 1268 struct pipe_context *context = tr_context->pipe; 1269 struct pipe_resource *texture = tr_res->resource; 1270 struct pipe_transfer *result = NULL; 1271 void *map; 1272 1273 assert(texture->screen == context->screen); 1274 1275 /* 1276 * Map and transfers can't be serialized so we convert all write transfers 1277 * to transfer_inline_write and ignore read transfers. 1278 */ 1279 1280 map = context->transfer_map(context, texture, level, usage, box, &result); 1281 if (!map) 1282 return NULL; 1283 1284 *transfer = trace_transfer_create(tr_context, tr_res, result); 1285 1286 if (map) { 1287 if(usage & PIPE_TRANSFER_WRITE) { 1288 trace_transfer(*transfer)->map = map; 1289 } 1290 } 1291 1292 return *transfer ? map : NULL; 1293} 1294 1295static void 1296trace_context_transfer_flush_region( struct pipe_context *_context, 1297 struct pipe_transfer *_transfer, 1298 const struct pipe_box *box) 1299{ 1300 struct trace_context *tr_context = trace_context(_context); 1301 struct trace_transfer *tr_transfer = trace_transfer(_transfer); 1302 struct pipe_context *context = tr_context->pipe; 1303 struct pipe_transfer *transfer = tr_transfer->transfer; 1304 1305 context->transfer_flush_region(context, 1306 transfer, 1307 box); 1308} 1309 1310static void 1311trace_context_transfer_unmap(struct pipe_context *_context, 1312 struct pipe_transfer *_transfer) 1313{ 1314 struct trace_context *tr_ctx = trace_context(_context); 1315 struct trace_transfer *tr_trans = trace_transfer(_transfer); 1316 struct pipe_context *context = tr_ctx->pipe; 1317 struct pipe_transfer *transfer = tr_trans->transfer; 1318 1319 if(tr_trans->map) { 1320 /* 1321 * Fake a transfer_inline_write 1322 */ 1323 1324 struct pipe_resource *resource = transfer->resource; 1325 unsigned level = transfer->level; 1326 unsigned usage = transfer->usage; 1327 const struct pipe_box *box = &transfer->box; 1328 unsigned stride = transfer->stride; 1329 unsigned layer_stride = transfer->layer_stride; 1330 1331 trace_dump_call_begin("pipe_context", "transfer_inline_write"); 1332 1333 trace_dump_arg(ptr, context); 1334 trace_dump_arg(ptr, resource); 1335 trace_dump_arg(uint, level); 1336 trace_dump_arg(uint, usage); 1337 trace_dump_arg(box, box); 1338 1339 trace_dump_arg_begin("data"); 1340 trace_dump_box_bytes(tr_trans->map, 1341 resource, 1342 box, 1343 stride, 1344 layer_stride); 1345 trace_dump_arg_end(); 1346 1347 trace_dump_arg(uint, stride); 1348 trace_dump_arg(uint, layer_stride); 1349 1350 trace_dump_call_end(); 1351 1352 tr_trans->map = NULL; 1353 } 1354 1355 context->transfer_unmap(context, transfer); 1356 trace_transfer_destroy(tr_ctx, tr_trans); 1357} 1358 1359 1360static void 1361trace_context_transfer_inline_write(struct pipe_context *_context, 1362 struct pipe_resource *_resource, 1363 unsigned level, 1364 unsigned usage, 1365 const struct pipe_box *box, 1366 const void *data, 1367 unsigned stride, 1368 unsigned layer_stride) 1369{ 1370 struct trace_context *tr_context = trace_context(_context); 1371 struct trace_resource *tr_res = trace_resource(_resource); 1372 struct pipe_context *context = tr_context->pipe; 1373 struct pipe_resource *resource = tr_res->resource; 1374 1375 assert(resource->screen == context->screen); 1376 1377 trace_dump_call_begin("pipe_context", "transfer_inline_write"); 1378 1379 trace_dump_arg(ptr, context); 1380 trace_dump_arg(ptr, resource); 1381 trace_dump_arg(uint, level); 1382 trace_dump_arg(uint, usage); 1383 trace_dump_arg(box, box); 1384 1385 trace_dump_arg_begin("data"); 1386 trace_dump_box_bytes(data, 1387 resource, 1388 box, 1389 stride, 1390 layer_stride); 1391 trace_dump_arg_end(); 1392 1393 trace_dump_arg(uint, stride); 1394 trace_dump_arg(uint, layer_stride); 1395 1396 trace_dump_call_end(); 1397 1398 context->transfer_inline_write(context, resource, 1399 level, usage, box, data, stride, layer_stride); 1400} 1401 1402 1403static void trace_context_render_condition(struct pipe_context *_context, 1404 struct pipe_query *query, 1405 boolean condition, 1406 uint mode) 1407{ 1408 struct trace_context *tr_context = trace_context(_context); 1409 struct pipe_context *context = tr_context->pipe; 1410 1411 trace_dump_call_begin("pipe_context", "render_condition"); 1412 1413 trace_dump_arg(ptr, context); 1414 trace_dump_arg(ptr, query); 1415 trace_dump_arg(bool, condition); 1416 trace_dump_arg(uint, mode); 1417 1418 trace_dump_call_end(); 1419 1420 context->render_condition(context, query, condition, mode); 1421} 1422 1423 1424static void trace_context_texture_barrier(struct pipe_context *_context) 1425{ 1426 struct trace_context *tr_context = trace_context(_context); 1427 struct pipe_context *context = tr_context->pipe; 1428 1429 trace_dump_call_begin("pipe_context", "texture_barrier"); 1430 1431 trace_dump_arg(ptr, context); 1432 1433 trace_dump_call_end(); 1434 1435 context->texture_barrier(context); 1436} 1437 1438 1439static const struct debug_named_value rbug_blocker_flags[] = { 1440 {"before", 1, NULL}, 1441 {"after", 2, NULL}, 1442 DEBUG_NAMED_VALUE_END 1443}; 1444 1445struct pipe_context * 1446trace_context_create(struct trace_screen *tr_scr, 1447 struct pipe_context *pipe) 1448{ 1449 struct trace_context *tr_ctx; 1450 1451 if(!pipe) 1452 goto error1; 1453 1454 if(!trace_enabled()) 1455 goto error1; 1456 1457 tr_ctx = CALLOC_STRUCT(trace_context); 1458 if(!tr_ctx) 1459 goto error1; 1460 1461 tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */ 1462 tr_ctx->base.screen = &tr_scr->base; 1463 1464 tr_ctx->base.destroy = trace_context_destroy; 1465 1466#define TR_CTX_INIT(_member) \ 1467 tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL 1468 1469 TR_CTX_INIT(draw_vbo); 1470 TR_CTX_INIT(render_condition); 1471 TR_CTX_INIT(create_query); 1472 TR_CTX_INIT(destroy_query); 1473 TR_CTX_INIT(begin_query); 1474 TR_CTX_INIT(end_query); 1475 TR_CTX_INIT(get_query_result); 1476 TR_CTX_INIT(create_blend_state); 1477 TR_CTX_INIT(bind_blend_state); 1478 TR_CTX_INIT(delete_blend_state); 1479 TR_CTX_INIT(create_sampler_state); 1480 TR_CTX_INIT(bind_sampler_states); 1481 TR_CTX_INIT(delete_sampler_state); 1482 TR_CTX_INIT(create_rasterizer_state); 1483 TR_CTX_INIT(bind_rasterizer_state); 1484 TR_CTX_INIT(delete_rasterizer_state); 1485 TR_CTX_INIT(create_depth_stencil_alpha_state); 1486 TR_CTX_INIT(bind_depth_stencil_alpha_state); 1487 TR_CTX_INIT(delete_depth_stencil_alpha_state); 1488 TR_CTX_INIT(create_fs_state); 1489 TR_CTX_INIT(bind_fs_state); 1490 TR_CTX_INIT(delete_fs_state); 1491 TR_CTX_INIT(create_vs_state); 1492 TR_CTX_INIT(bind_vs_state); 1493 TR_CTX_INIT(delete_vs_state); 1494 TR_CTX_INIT(create_gs_state); 1495 TR_CTX_INIT(bind_gs_state); 1496 TR_CTX_INIT(delete_gs_state); 1497 TR_CTX_INIT(create_vertex_elements_state); 1498 TR_CTX_INIT(bind_vertex_elements_state); 1499 TR_CTX_INIT(delete_vertex_elements_state); 1500 TR_CTX_INIT(set_blend_color); 1501 TR_CTX_INIT(set_stencil_ref); 1502 TR_CTX_INIT(set_clip_state); 1503 TR_CTX_INIT(set_sample_mask); 1504 TR_CTX_INIT(set_constant_buffer); 1505 TR_CTX_INIT(set_framebuffer_state); 1506 TR_CTX_INIT(set_polygon_stipple); 1507 TR_CTX_INIT(set_scissor_states); 1508 TR_CTX_INIT(set_viewport_states); 1509 TR_CTX_INIT(set_sampler_views); 1510 TR_CTX_INIT(create_sampler_view); 1511 TR_CTX_INIT(sampler_view_destroy); 1512 TR_CTX_INIT(create_surface); 1513 TR_CTX_INIT(surface_destroy); 1514 TR_CTX_INIT(set_vertex_buffers); 1515 TR_CTX_INIT(set_index_buffer); 1516 TR_CTX_INIT(create_stream_output_target); 1517 TR_CTX_INIT(stream_output_target_destroy); 1518 TR_CTX_INIT(set_stream_output_targets); 1519 TR_CTX_INIT(resource_copy_region); 1520 TR_CTX_INIT(blit); 1521 TR_CTX_INIT(flush_resource); 1522 TR_CTX_INIT(clear); 1523 TR_CTX_INIT(clear_render_target); 1524 TR_CTX_INIT(clear_depth_stencil); 1525 TR_CTX_INIT(flush); 1526 TR_CTX_INIT(texture_barrier); 1527 1528 TR_CTX_INIT(transfer_map); 1529 TR_CTX_INIT(transfer_unmap); 1530 TR_CTX_INIT(transfer_flush_region); 1531 TR_CTX_INIT(transfer_inline_write); 1532 1533#undef TR_CTX_INIT 1534 1535 tr_ctx->pipe = pipe; 1536 1537 return &tr_ctx->base; 1538 1539error1: 1540 return pipe; 1541} 1542 1543 1544/** 1545 * Sanity checker: check that the given context really is a 1546 * trace context (and not the wrapped driver's context). 1547 */ 1548void 1549trace_context_check(const struct pipe_context *pipe) 1550{ 1551 struct trace_context *tr_ctx = (struct trace_context *) pipe; 1552 assert(tr_ctx->base.destroy == trace_context_destroy); 1553} 1554 1555