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