src/gallium/drivers/trace/tr_context.c

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