src/gallium/drivers/trace/tr_context.c

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