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_tex;
  51
  52    if(!resource)
  53       return NULL;
  54
  55    tr_tex = trace_resource(resource);
  56
  57    assert(tr_tex->resource);
  58    return tr_tex->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_tex = trace_resource(_resource);
 836    struct pipe_context *pipe = tr_ctx->pipe;
 837    struct pipe_resource *texture = tr_tex->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, texture);
 845    trace_dump_arg(sampler_view_template, templ);
 846
 847    result = pipe->create_sampler_view(pipe, texture, templ);
 848
 849    trace_dump_ret(ptr, result);
 850
 851    trace_dump_call_end();
 852
 853    /*
 854     * Wrap pipe_sampler_view
 855     */
 856    tr_view = CALLOC_STRUCT(trace_sampler_view);
 857    tr_view->base = *templ;
 858    tr_view->base.reference.count = 1;
 859    tr_view->base.texture = NULL;
 860    pipe_resource_reference(&tr_view->base.texture, _resource);
 861    tr_view->base.context = _pipe;
 862    tr_view->sampler_view = result;
 863    result = &tr_view->base;
 864
 865    return result;
 866 }
 867
 868
 869 static void
 870 trace_sampler_view_destroy(struct pipe_context *_pipe,
 871                            struct pipe_sampler_view *_view)
 872 {
 873    struct trace_context *tr_ctx = trace_context(_pipe);
 874    struct trace_sampler_view *tr_view = trace_sampler_view(_view);
 875    struct pipe_context *pipe = tr_ctx->pipe;
 876    struct pipe_sampler_view *view = tr_view->sampler_view;
 877
 878    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
 879
 880    trace_dump_arg(ptr, pipe);
 881    trace_dump_arg(ptr, view);
 882
 883    pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
 884
 885    trace_dump_call_end();
 886
 887    pipe_resource_reference(&_view->texture, NULL);
 888    FREE(_view);
 889 }
 890
 891 /********************************************************************
 892  * surface
 893  */
 894
 895
 896 static struct pipe_surface *
 897 trace_create_surface(struct pipe_context *_pipe,
 898                      struct pipe_resource *_texture,
 899                      const struct pipe_surface *surf_tmpl)
 900 {
 901    struct trace_context *tr_ctx = trace_context(_pipe);
 902    struct trace_resource *tr_tex = trace_resource(_texture);
 903    struct pipe_context *pipe = tr_ctx->pipe;
 904    struct pipe_resource *texture = tr_tex->resource;
 905    struct pipe_surface *result = NULL;
 906
 907    trace_dump_call_begin("pipe_context", "create_surface");
 908
 909    trace_dump_arg(ptr, pipe);
 910    trace_dump_arg(ptr, texture);
 911    /* hmm some values unitialized there */
 912    trace_dump_arg(surface, surf_tmpl);
 913
 914    result = pipe->create_surface(pipe, texture, surf_tmpl);
 915
 916    trace_dump_ret(ptr, result);
 917
 918    trace_dump_call_end();
 919
 920    result = trace_surf_create(tr_tex, result);
 921
 922    return result;
 923 }
 924
 925
 926 static void
 927 trace_surface_destroy(struct pipe_context *_pipe,
 928                       struct pipe_surface *_surface)
 929 {
 930    struct trace_context *tr_ctx = trace_context(_pipe);
 931    struct pipe_context *pipe = tr_ctx->pipe;
 932    struct trace_surface *tr_surf = trace_surface(_surface);
 933    struct pipe_surface *surface = tr_surf->surface;
 934
 935    trace_dump_call_begin("pipe_context", "surface_destroy");
 936
 937    trace_dump_arg(ptr, pipe);
 938    trace_dump_arg(ptr, surface);
 939
 940    trace_dump_call_end();
 941
 942    trace_surf_destroy(tr_surf);
 943 }
 944
 945
 946 static INLINE void
 947 trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
 948                                          unsigned num,
 949                                          struct pipe_sampler_view **views)
 950 {
 951    struct trace_context *tr_ctx = trace_context(_pipe);
 952    struct trace_sampler_view *tr_view;
 953    struct pipe_context *pipe = tr_ctx->pipe;
 954    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
 955    unsigned i;
 956
 957    for(i = 0; i < num; ++i) {
 958       tr_view = trace_sampler_view(views[i]);
 959       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
 960    }
 961    views = unwrapped_views;
 962
 963    trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
 964
 965    trace_dump_arg(ptr, pipe);
 966    trace_dump_arg(uint, num);
 967    trace_dump_arg_array(ptr, views, num);
 968
 969    pipe->set_fragment_sampler_views(pipe, num, views);
 970
 971    trace_dump_call_end();
 972 }
 973
 974
 975 static INLINE void
 976 trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
 977                                        unsigned num,
 978                                        struct pipe_sampler_view **views)
 979 {
 980    struct trace_context *tr_ctx = trace_context(_pipe);
 981    struct trace_sampler_view *tr_view;
 982    struct pipe_context *pipe = tr_ctx->pipe;
 983    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
 984    unsigned i;
 985
 986    if (!pipe->set_vertex_sampler_views)
 987       return;
 988
 989    for(i = 0; i < num; ++i) {
 990       tr_view = trace_sampler_view(views[i]);
 991       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
 992    }
 993    views = unwrapped_views;
 994
 995    trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
 996
 997    trace_dump_arg(ptr, pipe);
 998    trace_dump_arg(uint, num);
 999    trace_dump_arg_array(ptr, views, num);
1000
1001    pipe->set_vertex_sampler_views(pipe, num, views);
1002
1003    trace_dump_call_end();
1004 }
1005
1006
1007 static INLINE void
1008 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1009                                  unsigned num_buffers,
1010                                  const struct pipe_vertex_buffer *buffers)
1011 {
1012    struct trace_context *tr_ctx = trace_context(_pipe);
1013    struct pipe_context *pipe = tr_ctx->pipe;
1014    unsigned i;
1015
1016    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1017
1018    trace_dump_arg(ptr, pipe);
1019    trace_dump_arg(uint, num_buffers);
1020
1021    trace_dump_arg_begin("buffers");
1022    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1023    trace_dump_arg_end();
1024
1025    if (num_buffers) {
1026       struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
1027       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1028       for (i = 0; i < num_buffers; i++)
1029          _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
1030       pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1031       FREE(_buffers);
1032    } else {
1033       pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1034    }
1035
1036    trace_dump_call_end();
1037 }
1038
1039
1040 static INLINE void
1041 trace_context_set_index_buffer(struct pipe_context *_pipe,
1042                                const struct pipe_index_buffer *ib)
1043 {
1044    struct trace_context *tr_ctx = trace_context(_pipe);
1045    struct pipe_context *pipe = tr_ctx->pipe;
1046
1047    trace_dump_call_begin("pipe_context", "set_index_buffer");
1048
1049    trace_dump_arg(ptr, pipe);
1050    trace_dump_arg(index_buffer, ib);
1051
1052    if (ib) {
1053       struct pipe_index_buffer _ib;
1054       _ib = *ib;
1055       _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer);
1056       pipe->set_index_buffer(pipe, &_ib);
1057    } else {
1058       pipe->set_index_buffer(pipe, NULL);
1059    }
1060
1061    trace_dump_call_end();
1062 }
1063
1064 static INLINE void
1065 trace_context_resource_copy_region(struct pipe_context *_pipe,
1066                                    struct pipe_resource *dst,
1067                                    unsigned dst_level,
1068                                    unsigned dstx, unsigned dsty, unsigned dstz,
1069                                    struct pipe_resource *src,
1070                                    unsigned src_level,
1071                                    const struct pipe_box *src_box)
1072 {
1073    struct trace_context *tr_ctx = trace_context(_pipe);
1074    struct pipe_context *pipe = tr_ctx->pipe;
1075
1076    dst = trace_resource_unwrap(tr_ctx, dst);
1077    src = trace_resource_unwrap(tr_ctx, src);
1078
1079    trace_dump_call_begin("pipe_context", "resource_copy_region");
1080
1081    trace_dump_arg(ptr, pipe);
1082    trace_dump_arg(ptr, dst);
1083    trace_dump_arg(uint, dst_level);
1084    trace_dump_arg(uint, dstx);
1085    trace_dump_arg(uint, dsty);
1086    trace_dump_arg(uint, dstz);
1087    trace_dump_arg(ptr, src);
1088    trace_dump_arg(uint, src_level);
1089    trace_dump_arg(box, src_box);
1090
1091    pipe->resource_copy_region(pipe,
1092                               dst, dst_level, dstx, dsty, dstz,
1093                               src, src_level, src_box);
1094
1095    trace_dump_call_end();
1096 }
1097
1098
1099 static INLINE void
1100 trace_context_clear(struct pipe_context *_pipe,
1101                     unsigned buffers,
1102                     const float *rgba,
1103                     double depth,
1104                     unsigned stencil)
1105 {
1106    struct trace_context *tr_ctx = trace_context(_pipe);
1107    struct pipe_context *pipe = tr_ctx->pipe;
1108
1109    trace_dump_call_begin("pipe_context", "clear");
1110
1111    trace_dump_arg(ptr, pipe);
1112    trace_dump_arg(uint, buffers);
1113    if (rgba)
1114       trace_dump_arg_array(float, rgba, 4);
1115    else
1116       trace_dump_null();
1117    trace_dump_arg(float, depth);
1118    trace_dump_arg(uint, stencil);
1119
1120    pipe->clear(pipe, buffers, rgba, depth, stencil);
1121
1122    trace_dump_call_end();
1123 }
1124
1125
1126 static INLINE void
1127 trace_context_clear_render_target(struct pipe_context *_pipe,
1128                                   struct pipe_surface *dst,
1129                                   const float *rgba,
1130                                   unsigned dstx, unsigned dsty,
1131                                   unsigned width, unsigned height)
1132 {
1133    struct trace_context *tr_ctx = trace_context(_pipe);
1134    struct pipe_context *pipe = tr_ctx->pipe;
1135
1136    dst = trace_surface_unwrap(tr_ctx, dst);
1137
1138    trace_dump_call_begin("pipe_context", "clear_render_target");
1139
1140    trace_dump_arg(ptr, pipe);
1141    trace_dump_arg(ptr, dst);
1142    trace_dump_arg_array(float, rgba, 4);
1143    trace_dump_arg(uint, dstx);
1144    trace_dump_arg(uint, dsty);
1145    trace_dump_arg(uint, width);
1146    trace_dump_arg(uint, height);
1147
1148    pipe->clear_render_target(pipe, dst, rgba, dstx, dsty, width, height);
1149
1150    trace_dump_call_end();
1151 }
1152
1153 static INLINE void
1154 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1155                                   struct pipe_surface *dst,
1156                                   unsigned clear_flags,
1157                                   double depth,
1158                                   unsigned stencil,
1159                                   unsigned dstx, unsigned dsty,
1160                                   unsigned width, unsigned height)
1161 {
1162    struct trace_context *tr_ctx = trace_context(_pipe);
1163    struct pipe_context *pipe = tr_ctx->pipe;
1164
1165    dst = trace_surface_unwrap(tr_ctx, dst);
1166
1167    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1168
1169    trace_dump_arg(ptr, pipe);
1170    trace_dump_arg(ptr, dst);
1171    trace_dump_arg(uint, clear_flags);
1172    trace_dump_arg(float, depth);
1173    trace_dump_arg(uint, stencil);
1174    trace_dump_arg(uint, dstx);
1175    trace_dump_arg(uint, dsty);
1176    trace_dump_arg(uint, width);
1177    trace_dump_arg(uint, height);
1178
1179    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1180                              dstx, dsty, width, height);
1181
1182    trace_dump_call_end();
1183 }
1184
1185 static INLINE void
1186 trace_context_flush(struct pipe_context *_pipe,
1187                     unsigned flags,
1188                     struct pipe_fence_handle **fence)
1189 {
1190    struct trace_context *tr_ctx = trace_context(_pipe);
1191    struct pipe_context *pipe = tr_ctx->pipe;
1192
1193    trace_dump_call_begin("pipe_context", "flush");
1194
1195    trace_dump_arg(ptr, pipe);
1196    trace_dump_arg(uint, flags);
1197
1198    pipe->flush(pipe, flags, fence);
1199
1200    if(fence)
1201       trace_dump_ret(ptr, *fence);
1202
1203    trace_dump_call_end();
1204 }
1205
1206
1207 static INLINE void
1208 trace_context_destroy(struct pipe_context *_pipe)
1209 {
1210    struct trace_context *tr_ctx = trace_context(_pipe);
1211    struct pipe_context *pipe = tr_ctx->pipe;
1212
1213    trace_dump_call_begin("pipe_context", "destroy");
1214    trace_dump_arg(ptr, pipe);
1215    trace_dump_call_end();
1216
1217    pipe->destroy(pipe);
1218
1219    FREE(tr_ctx);
1220 }
1221
1222 static unsigned int
1223 trace_is_resource_referenced( struct pipe_context *_pipe,
1224                               struct pipe_resource *_resource,
1225                               unsigned level, int layer)
1226 {
1227    struct trace_context *tr_ctx = trace_context(_pipe);
1228    struct trace_resource *tr_tex = trace_resource(_resource);
1229    struct pipe_context *pipe = tr_ctx->pipe;
1230    struct pipe_resource *texture = tr_tex->resource;
1231    unsigned int referenced;
1232
1233    trace_dump_call_begin("pipe_context", "is_resource_referenced");
1234    trace_dump_arg(ptr, pipe);
1235    trace_dump_arg(ptr, texture);
1236    trace_dump_arg(uint, level);
1237    trace_dump_arg(int, layer);
1238
1239    referenced = pipe->is_resource_referenced(pipe, texture, level, layer);
1240
1241    trace_dump_ret(uint, referenced);
1242    trace_dump_call_end();
1243
1244    return referenced;
1245 }
1246
1247
1248 /********************************************************************
1249  * transfer
1250  */
1251
1252
1253 static struct pipe_transfer *
1254 trace_context_get_transfer(struct pipe_context *_context,
1255                            struct pipe_resource *_resource,
1256                            unsigned level,
1257                            unsigned usage,
1258                            const struct pipe_box *box)
1259 {
1260    struct trace_context *tr_context = trace_context(_context);
1261    struct trace_resource *tr_tex = trace_resource(_resource);
1262    struct pipe_context *context = tr_context->pipe;
1263    struct pipe_resource *texture = tr_tex->resource;
1264    struct pipe_transfer *result = NULL;
1265
1266    assert(texture->screen == context->screen);
1267
1268    /*
1269     * Map and transfers can't be serialized so we convert all write transfers
1270     * to transfer_inline_write and ignore read transfers.
1271     */
1272
1273    result = context->get_transfer(context, texture, level, usage, box);
1274
1275    if (result)
1276       result = trace_transfer_create(tr_context, tr_tex, result);
1277
1278    return result;
1279 }
1280
1281
1282 static void
1283 trace_context_transfer_destroy(struct pipe_context *_context,
1284                                struct pipe_transfer *_transfer)
1285 {
1286    struct trace_context *tr_context = trace_context(_context);
1287    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1288
1289    trace_transfer_destroy(tr_context, tr_trans);
1290 }
1291
1292
1293 static void *
1294 trace_context_transfer_map(struct pipe_context *_context,
1295                           struct pipe_transfer *_transfer)
1296 {
1297    struct trace_context *tr_context = trace_context(_context);
1298    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1299    struct pipe_context *context = tr_context->pipe;
1300    struct pipe_transfer *transfer = tr_trans->transfer;
1301    void *map;
1302
1303    map = context->transfer_map(context, transfer);
1304    if(map) {
1305       if(transfer->usage & PIPE_TRANSFER_WRITE) {
1306          assert(!tr_trans->map);
1307          tr_trans->map = map;
1308       }
1309    }
1310
1311    return map;
1312 }
1313
1314
1315 static void
1316 trace_context_transfer_flush_region( struct pipe_context *_context,
1317                                      struct pipe_transfer *_transfer,
1318                                      const struct pipe_box *box)
1319 {
1320    struct trace_context *tr_context = trace_context(_context);
1321    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1322    struct pipe_context *context = tr_context->pipe;
1323    struct pipe_transfer *transfer = tr_transfer->transfer;
1324
1325    context->transfer_flush_region(context,
1326                                   transfer,
1327                                   box);
1328 }
1329
1330 static void
1331 trace_context_transfer_unmap(struct pipe_context *_context,
1332                              struct pipe_transfer *_transfer)
1333 {
1334    struct trace_context *tr_ctx = trace_context(_context);
1335    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1336    struct pipe_context *context = tr_ctx->pipe;
1337    struct pipe_transfer *transfer = tr_trans->transfer;
1338
1339    if(tr_trans->map) {
1340       /*
1341        * Fake a transfer_inline_write
1342        */
1343
1344       struct pipe_resource *resource = transfer->resource;
1345       unsigned level = transfer->level;
1346       unsigned usage = transfer->usage;
1347       const struct pipe_box *box = &transfer->box;
1348       unsigned stride = transfer->stride;
1349       unsigned layer_stride = transfer->layer_stride;
1350
1351       trace_dump_call_begin("pipe_context", "transfer_inline_write");
1352
1353       trace_dump_arg(ptr, context);
1354       trace_dump_arg(ptr, resource);
1355       trace_dump_arg(uint, level);
1356       trace_dump_arg(uint, usage);
1357       trace_dump_arg(box, box);
1358
1359       trace_dump_arg_begin("data");
1360       trace_dump_box_bytes(tr_trans->map,
1361                            resource->format,
1362                            box,
1363                            stride,
1364                            layer_stride);
1365       trace_dump_arg_end();
1366
1367       trace_dump_arg(uint, stride);
1368       trace_dump_arg(uint, layer_stride);
1369
1370       trace_dump_call_end();
1371
1372       tr_trans->map = NULL;
1373    }
1374
1375    context->transfer_unmap(context, transfer);
1376 }
1377
1378
1379 static void
1380 trace_context_transfer_inline_write(struct pipe_context *_context,
1381                                     struct pipe_resource *_resource,
1382                                     unsigned level,
1383                                     unsigned usage,
1384                                     const struct pipe_box *box,
1385                                     const void *data,
1386                                     unsigned stride,
1387                                     unsigned layer_stride)
1388 {
1389    struct trace_context *tr_context = trace_context(_context);
1390    struct trace_resource *tr_tex = trace_resource(_resource);
1391    struct pipe_context *context = tr_context->pipe;
1392    struct pipe_resource *resource = tr_tex->resource;
1393
1394    assert(resource->screen == context->screen);
1395
1396    trace_dump_call_begin("pipe_context", "transfer_inline_write");
1397
1398    trace_dump_arg(ptr, context);
1399    trace_dump_arg(ptr, resource);
1400    trace_dump_arg(uint, level);
1401    trace_dump_arg(uint, usage);
1402    trace_dump_arg(box, box);
1403
1404    trace_dump_arg_begin("data");
1405    trace_dump_box_bytes(data,
1406                         resource->format,
1407                         box,
1408                         stride,
1409                         layer_stride);
1410    trace_dump_arg_end();
1411
1412    trace_dump_arg(uint, stride);
1413    trace_dump_arg(uint, layer_stride);
1414
1415    trace_dump_call_end();
1416
1417    context->transfer_inline_write(context, resource,
1418                                   level, usage, box, data, stride, layer_stride);
1419 }
1420
1421
1422
1423
1424 static const struct debug_named_value rbug_blocker_flags[] = {
1425    {"before", 1, NULL},
1426    {"after", 2, NULL},
1427    DEBUG_NAMED_VALUE_END
1428 };
1429
1430 struct pipe_context *
1431 trace_context_create(struct trace_screen *tr_scr,
1432                      struct pipe_context *pipe)
1433 {
1434    struct trace_context *tr_ctx;
1435
1436    if(!pipe)
1437       goto error1;
1438
1439    if(!trace_enabled())
1440       goto error1;
1441
1442    tr_ctx = CALLOC_STRUCT(trace_context);
1443    if(!tr_ctx)
1444       goto error1;
1445
1446    tr_ctx->base.winsys = NULL;
1447    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1448    tr_ctx->base.screen = &tr_scr->base;
1449
1450    tr_ctx->base.destroy = trace_context_destroy;
1451    tr_ctx->base.draw_vbo = trace_context_draw_vbo;
1452    tr_ctx->base.create_query = trace_context_create_query;
1453    tr_ctx->base.destroy_query = trace_context_destroy_query;
1454    tr_ctx->base.begin_query = trace_context_begin_query;
1455    tr_ctx->base.end_query = trace_context_end_query;
1456    tr_ctx->base.get_query_result = trace_context_get_query_result;
1457    tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1458    tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1459    tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1460    tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1461    tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1462    tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1463    tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1464    tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1465    tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1466    tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1467    tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1468    tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1469    tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1470    tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1471    tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1472    tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1473    tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1474    tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1475    tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1476    tr_ctx->base.create_vertex_elements_state = trace_context_create_vertex_elements_state;
1477    tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state;
1478    tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state;
1479    tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1480    tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
1481    tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1482    tr_ctx->base.set_sample_mask = trace_context_set_sample_mask;
1483    tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1484    tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1485    tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1486    tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1487    tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1488    tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
1489    tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
1490    tr_ctx->base.create_sampler_view = trace_create_sampler_view;
1491    tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy;
1492    tr_ctx->base.create_surface = trace_create_surface;
1493    tr_ctx->base.surface_destroy = trace_surface_destroy;
1494    tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1495    tr_ctx->base.set_index_buffer = trace_context_set_index_buffer;
1496    tr_ctx->base.resource_copy_region = trace_context_resource_copy_region;
1497    tr_ctx->base.clear = trace_context_clear;
1498    tr_ctx->base.clear_render_target = trace_context_clear_render_target;
1499    tr_ctx->base.clear_depth_stencil = trace_context_clear_depth_stencil;
1500    tr_ctx->base.flush = trace_context_flush;
1501    tr_ctx->base.is_resource_referenced = trace_is_resource_referenced;
1502
1503    tr_ctx->base.get_transfer = trace_context_get_transfer;
1504    tr_ctx->base.transfer_destroy = trace_context_transfer_destroy;
1505    tr_ctx->base.transfer_map = trace_context_transfer_map;
1506    tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
1507    tr_ctx->base.transfer_flush_region = trace_context_transfer_flush_region;
1508    tr_ctx->base.transfer_inline_write = trace_context_transfer_inline_write;
1509
1510    tr_ctx->pipe = pipe;
1511
1512    return &tr_ctx->base;
1513
1514 error1:
1515    return pipe;
1516 }