src/gallium/drivers/trace/tr_context.c

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