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