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_state(struct pipe_context *_pipe,
 769                                 const struct pipe_scissor_state *state)
 770 {
 771    struct trace_context *tr_ctx = trace_context(_pipe);
 772    struct pipe_context *pipe = tr_ctx->pipe;
 773
 774    trace_dump_call_begin("pipe_context", "set_scissor_state");
 775
 776    trace_dump_arg(ptr, pipe);
 777    trace_dump_arg(scissor_state, state);
 778
 779    pipe->set_scissor_state(pipe, state);
 780
 781    trace_dump_call_end();
 782 }
 783
 784
 785 static INLINE void
 786 trace_context_set_viewport_state(struct pipe_context *_pipe,
 787                                  const struct pipe_viewport_state *state)
 788 {
 789    struct trace_context *tr_ctx = trace_context(_pipe);
 790    struct pipe_context *pipe = tr_ctx->pipe;
 791
 792    trace_dump_call_begin("pipe_context", "set_viewport_state");
 793
 794    trace_dump_arg(ptr, pipe);
 795    trace_dump_arg(viewport_state, state);
 796
 797    pipe->set_viewport_state(pipe, state);
 798
 799    trace_dump_call_end();
 800 }
 801
 802
 803 static struct pipe_sampler_view *
 804 trace_context_create_sampler_view(struct pipe_context *_pipe,
 805                           struct pipe_resource *_resource,
 806                           const struct pipe_sampler_view *templ)
 807 {
 808    struct trace_context *tr_ctx = trace_context(_pipe);
 809    struct trace_resource *tr_res = trace_resource(_resource);
 810    struct pipe_context *pipe = tr_ctx->pipe;
 811    struct pipe_resource *resource = tr_res->resource;
 812    struct pipe_sampler_view *result;
 813    struct trace_sampler_view *tr_view;
 814
 815    trace_dump_call_begin("pipe_context", "create_sampler_view");
 816
 817    trace_dump_arg(ptr, pipe);
 818    trace_dump_arg(ptr, resource);
 819
 820    trace_dump_arg_begin("templ");
 821    trace_dump_sampler_view_template(templ, resource->target);
 822    trace_dump_arg_end();
 823
 824    result = pipe->create_sampler_view(pipe, resource, templ);
 825
 826    trace_dump_ret(ptr, result);
 827
 828    trace_dump_call_end();
 829
 830    /*
 831     * Wrap pipe_sampler_view
 832     */
 833    tr_view = CALLOC_STRUCT(trace_sampler_view);
 834    tr_view->base = *templ;
 835    tr_view->base.reference.count = 1;
 836    tr_view->base.texture = NULL;
 837    pipe_resource_reference(&tr_view->base.texture, _resource);
 838    tr_view->base.context = _pipe;
 839    tr_view->sampler_view = result;
 840    result = &tr_view->base;
 841
 842    return result;
 843 }
 844
 845
 846 static void
 847 trace_context_sampler_view_destroy(struct pipe_context *_pipe,
 848                            struct pipe_sampler_view *_view)
 849 {
 850    struct trace_context *tr_ctx = trace_context(_pipe);
 851    struct trace_sampler_view *tr_view = trace_sampler_view(_view);
 852    struct pipe_context *pipe = tr_ctx->pipe;
 853    struct pipe_sampler_view *view = tr_view->sampler_view;
 854
 855    assert(_view->context == _pipe);
 856
 857    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
 858
 859    trace_dump_arg(ptr, pipe);
 860    trace_dump_arg(ptr, view);
 861
 862    pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
 863
 864    trace_dump_call_end();
 865
 866    pipe_resource_reference(&_view->texture, NULL);
 867    FREE(_view);
 868 }
 869
 870 /********************************************************************
 871  * surface
 872  */
 873
 874
 875 static struct pipe_surface *
 876 trace_context_create_surface(struct pipe_context *_pipe,
 877                              struct pipe_resource *_resource,
 878                              const struct pipe_surface *surf_tmpl)
 879 {
 880    struct trace_context *tr_ctx = trace_context(_pipe);
 881    struct trace_resource *tr_res = trace_resource(_resource);
 882    struct pipe_context *pipe = tr_ctx->pipe;
 883    struct pipe_resource *resource = tr_res->resource;
 884    struct pipe_surface *result = NULL;
 885
 886    trace_dump_call_begin("pipe_context", "create_surface");
 887
 888    trace_dump_arg(ptr, pipe);
 889    trace_dump_arg(ptr, resource);
 890
 891    trace_dump_arg_begin("surf_tmpl");
 892    trace_dump_surface_template(surf_tmpl, resource->target);
 893    trace_dump_arg_end();
 894
 895
 896    result = pipe->create_surface(pipe, resource, surf_tmpl);
 897
 898    trace_dump_ret(ptr, result);
 899
 900    trace_dump_call_end();
 901
 902    result = trace_surf_create(tr_ctx, tr_res, result);
 903
 904    return result;
 905 }
 906
 907
 908 static void
 909 trace_context_surface_destroy(struct pipe_context *_pipe,
 910                               struct pipe_surface *_surface)
 911 {
 912    struct trace_context *tr_ctx = trace_context(_pipe);
 913    struct pipe_context *pipe = tr_ctx->pipe;
 914    struct trace_surface *tr_surf = trace_surface(_surface);
 915    struct pipe_surface *surface = tr_surf->surface;
 916
 917    trace_dump_call_begin("pipe_context", "surface_destroy");
 918
 919    trace_dump_arg(ptr, pipe);
 920    trace_dump_arg(ptr, surface);
 921
 922    trace_dump_call_end();
 923
 924    trace_surf_destroy(tr_surf);
 925 }
 926
 927
 928 static INLINE void
 929 trace_context_set_sampler_views(struct pipe_context *_pipe,
 930                                 unsigned shader,
 931                                 unsigned start,
 932                                 unsigned num,
 933                                 struct pipe_sampler_view **views)
 934 {
 935    struct trace_context *tr_ctx = trace_context(_pipe);
 936    struct trace_sampler_view *tr_view;
 937    struct pipe_context *pipe = tr_ctx->pipe;
 938    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
 939    unsigned i;
 940
 941    /* remove this when we have pipe->set_sampler_views(..., start, ...) */
 942    assert(start == 0);
 943
 944    for(i = 0; i < num; ++i) {
 945       tr_view = trace_sampler_view(views[i]);
 946       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
 947    }
 948    views = unwrapped_views;
 949
 950    switch (shader) {
 951    case PIPE_SHADER_VERTEX:
 952       trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
 953       break;
 954    case PIPE_SHADER_GEOMETRY:
 955       trace_dump_call_begin("pipe_context", "set_geometry_sampler_views");
 956       break;
 957    case PIPE_SHADER_FRAGMENT:
 958       trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
 959       break;
 960    default:
 961       debug_error("Unexpected shader in trace_context_set_sampler_views()");
 962    }
 963
 964    trace_dump_arg(ptr, pipe);
 965    /*trace_dump_arg(uint, shader);*/
 966    trace_dump_arg(uint, num);
 967    trace_dump_arg_array(ptr, views, num);
 968
 969    switch (shader) {
 970    case PIPE_SHADER_VERTEX:
 971       pipe->set_vertex_sampler_views(pipe, num, views);
 972       break;
 973    case PIPE_SHADER_GEOMETRY:
 974       pipe->set_geometry_sampler_views(pipe, num, views);
 975       break;
 976    case PIPE_SHADER_FRAGMENT:
 977       pipe->set_fragment_sampler_views(pipe, num, views);
 978       break;
 979    default:
 980       debug_error("Unexpected shader in trace_context_set_sampler_views()");
 981    }
 982
 983    trace_dump_call_end();
 984 }
 985
 986
 987 static INLINE void
 988 trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
 989                                          unsigned num,
 990                                          struct pipe_sampler_view **views)
 991 {
 992    trace_context_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 0, num, views);
 993 }
 994
 995
 996 static INLINE void
 997 trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
 998                                        unsigned num,
 999                                        struct pipe_sampler_view **views)
1000 {
1001    trace_context_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 0, num, views);
1002 }
1003
1004
1005 static INLINE void
1006 trace_context_set_geometry_sampler_views(struct pipe_context *_pipe,
1007                                        unsigned num,
1008                                        struct pipe_sampler_view **views)
1009 {
1010    trace_context_set_sampler_views(_pipe, PIPE_SHADER_GEOMETRY, 0, num, views);
1011 }
1012
1013
1014 static INLINE void
1015 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1016                                  unsigned start_slot, unsigned num_buffers,
1017                                  const struct pipe_vertex_buffer *buffers)
1018 {
1019    struct trace_context *tr_ctx = trace_context(_pipe);
1020    struct pipe_context *pipe = tr_ctx->pipe;
1021    unsigned i;
1022
1023    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1024
1025    trace_dump_arg(ptr, pipe);
1026    trace_dump_arg(uint, start_slot);
1027    trace_dump_arg(uint, num_buffers);
1028
1029    trace_dump_arg_begin("buffers");
1030    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1031    trace_dump_arg_end();
1032
1033    if (buffers) {
1034       struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
1035       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1036       for (i = 0; i < num_buffers; i++)
1037          _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
1038       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers);
1039       FREE(_buffers);
1040    } else {
1041       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL);
1042    }
1043
1044    trace_dump_call_end();
1045 }
1046
1047
1048 static INLINE void
1049 trace_context_set_index_buffer(struct pipe_context *_pipe,
1050                                const struct pipe_index_buffer *ib)
1051 {
1052    struct trace_context *tr_ctx = trace_context(_pipe);
1053    struct pipe_context *pipe = tr_ctx->pipe;
1054
1055    trace_dump_call_begin("pipe_context", "set_index_buffer");
1056
1057    trace_dump_arg(ptr, pipe);
1058    trace_dump_arg(index_buffer, ib);
1059
1060    if (ib) {
1061       struct pipe_index_buffer _ib;
1062       _ib = *ib;
1063       _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer);
1064       pipe->set_index_buffer(pipe, &_ib);
1065    } else {
1066       pipe->set_index_buffer(pipe, NULL);
1067    }
1068
1069    trace_dump_call_end();
1070 }
1071
1072
1073 static INLINE struct pipe_stream_output_target *
1074 trace_context_create_stream_output_target(struct pipe_context *_pipe,
1075                                           struct pipe_resource *res,
1076                                           unsigned buffer_offset,
1077                                           unsigned buffer_size)
1078 {
1079    struct trace_context *tr_ctx = trace_context(_pipe);
1080    struct pipe_context *pipe = tr_ctx->pipe;
1081    struct pipe_stream_output_target *result;
1082
1083    res = trace_resource_unwrap(tr_ctx, res);
1084
1085    trace_dump_call_begin("pipe_context", "create_stream_output_target");
1086
1087    trace_dump_arg(ptr, pipe);
1088    trace_dump_arg(ptr, res);
1089    trace_dump_arg(uint, buffer_offset);
1090    trace_dump_arg(uint, buffer_size);
1091
1092    result = pipe->create_stream_output_target(pipe,
1093                                               res, buffer_offset, buffer_size);
1094
1095    trace_dump_call_end();
1096
1097    return result;
1098 }
1099
1100
1101 static INLINE void
1102 trace_context_stream_output_target_destroy(
1103    struct pipe_context *_pipe,
1104    struct pipe_stream_output_target *target)
1105 {
1106    struct trace_context *tr_ctx = trace_context(_pipe);
1107    struct pipe_context *pipe = tr_ctx->pipe;
1108
1109    trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1110
1111    trace_dump_arg(ptr, pipe);
1112    trace_dump_arg(ptr, target);
1113
1114    pipe->stream_output_target_destroy(pipe, target);
1115
1116    trace_dump_call_end();
1117 }
1118
1119
1120 static INLINE void
1121 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1122                                         unsigned num_targets,
1123                                         struct pipe_stream_output_target **tgs,
1124                                         unsigned append_bitmask)
1125 {
1126    struct trace_context *tr_ctx = trace_context(_pipe);
1127    struct pipe_context *pipe = tr_ctx->pipe;
1128
1129    trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1130
1131    trace_dump_arg(ptr, pipe);
1132    trace_dump_arg(uint, num_targets);
1133    trace_dump_arg_array(ptr, tgs, num_targets);
1134    trace_dump_arg(uint, append_bitmask);
1135
1136    pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask);
1137
1138    trace_dump_call_end();
1139 }
1140
1141
1142 static INLINE void
1143 trace_context_resource_copy_region(struct pipe_context *_pipe,
1144                                    struct pipe_resource *dst,
1145                                    unsigned dst_level,
1146                                    unsigned dstx, unsigned dsty, unsigned dstz,
1147                                    struct pipe_resource *src,
1148                                    unsigned src_level,
1149                                    const struct pipe_box *src_box)
1150 {
1151    struct trace_context *tr_ctx = trace_context(_pipe);
1152    struct pipe_context *pipe = tr_ctx->pipe;
1153
1154    dst = trace_resource_unwrap(tr_ctx, dst);
1155    src = trace_resource_unwrap(tr_ctx, src);
1156
1157    trace_dump_call_begin("pipe_context", "resource_copy_region");
1158
1159    trace_dump_arg(ptr, pipe);
1160    trace_dump_arg(ptr, dst);
1161    trace_dump_arg(uint, dst_level);
1162    trace_dump_arg(uint, dstx);
1163    trace_dump_arg(uint, dsty);
1164    trace_dump_arg(uint, dstz);
1165    trace_dump_arg(ptr, src);
1166    trace_dump_arg(uint, src_level);
1167    trace_dump_arg(box, src_box);
1168
1169    pipe->resource_copy_region(pipe,
1170                               dst, dst_level, dstx, dsty, dstz,
1171                               src, src_level, src_box);
1172
1173    trace_dump_call_end();
1174 }
1175
1176
1177 static INLINE void
1178 trace_context_blit(struct pipe_context *_pipe,
1179                    const struct pipe_blit_info *_info)
1180 {
1181    struct trace_context *tr_ctx = trace_context(_pipe);
1182    struct pipe_context *pipe = tr_ctx->pipe;
1183    struct pipe_blit_info info = *_info;
1184
1185    info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
1186    info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
1187
1188    trace_dump_call_begin("pipe_context", "blit");
1189
1190    trace_dump_arg(ptr, pipe);
1191    trace_dump_arg(blit_info, _info);
1192
1193    pipe->blit(pipe, &info);
1194
1195    trace_dump_call_end();
1196 }
1197
1198
1199 static INLINE void
1200 trace_context_clear(struct pipe_context *_pipe,
1201                     unsigned buffers,
1202                     const union pipe_color_union *color,
1203                     double depth,
1204                     unsigned stencil)
1205 {
1206    struct trace_context *tr_ctx = trace_context(_pipe);
1207    struct pipe_context *pipe = tr_ctx->pipe;
1208
1209    trace_dump_call_begin("pipe_context", "clear");
1210
1211    trace_dump_arg(ptr, pipe);
1212    trace_dump_arg(uint, buffers);
1213    trace_dump_arg_begin("color");
1214    if (color)
1215       trace_dump_array(float, color->f, 4);
1216    else
1217       trace_dump_null();
1218    trace_dump_arg_end();
1219    trace_dump_arg(float, depth);
1220    trace_dump_arg(uint, stencil);
1221
1222    pipe->clear(pipe, buffers, color, depth, stencil);
1223
1224    trace_dump_call_end();
1225 }
1226
1227
1228 static INLINE void
1229 trace_context_clear_render_target(struct pipe_context *_pipe,
1230                                   struct pipe_surface *dst,
1231                                   const union pipe_color_union *color,
1232                                   unsigned dstx, unsigned dsty,
1233                                   unsigned width, unsigned height)
1234 {
1235    struct trace_context *tr_ctx = trace_context(_pipe);
1236    struct pipe_context *pipe = tr_ctx->pipe;
1237
1238    dst = trace_surface_unwrap(tr_ctx, dst);
1239
1240    trace_dump_call_begin("pipe_context", "clear_render_target");
1241
1242    trace_dump_arg(ptr, pipe);
1243    trace_dump_arg(ptr, dst);
1244    trace_dump_arg_array(float, color->f, 4);
1245    trace_dump_arg(uint, dstx);
1246    trace_dump_arg(uint, dsty);
1247    trace_dump_arg(uint, width);
1248    trace_dump_arg(uint, height);
1249
1250    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
1251
1252    trace_dump_call_end();
1253 }
1254
1255 static INLINE void
1256 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1257                                   struct pipe_surface *dst,
1258                                   unsigned clear_flags,
1259                                   double depth,
1260                                   unsigned stencil,
1261                                   unsigned dstx, unsigned dsty,
1262                                   unsigned width, unsigned height)
1263 {
1264    struct trace_context *tr_ctx = trace_context(_pipe);
1265    struct pipe_context *pipe = tr_ctx->pipe;
1266
1267    dst = trace_surface_unwrap(tr_ctx, dst);
1268
1269    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1270
1271    trace_dump_arg(ptr, pipe);
1272    trace_dump_arg(ptr, dst);
1273    trace_dump_arg(uint, clear_flags);
1274    trace_dump_arg(float, depth);
1275    trace_dump_arg(uint, stencil);
1276    trace_dump_arg(uint, dstx);
1277    trace_dump_arg(uint, dsty);
1278    trace_dump_arg(uint, width);
1279    trace_dump_arg(uint, height);
1280
1281    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1282                              dstx, dsty, width, height);
1283
1284    trace_dump_call_end();
1285 }
1286
1287 static INLINE void
1288 trace_context_flush(struct pipe_context *_pipe,
1289                     struct pipe_fence_handle **fence,
1290                     enum pipe_flush_flags flags)
1291 {
1292    struct trace_context *tr_ctx = trace_context(_pipe);
1293    struct pipe_context *pipe = tr_ctx->pipe;
1294
1295    trace_dump_call_begin("pipe_context", "flush");
1296
1297    trace_dump_arg(ptr, pipe);
1298    trace_dump_arg(uint, flags);
1299
1300    pipe->flush(pipe, fence, flags);
1301
1302    if(fence)
1303       trace_dump_ret(ptr, *fence);
1304
1305    trace_dump_call_end();
1306 }
1307
1308
1309 static INLINE void
1310 trace_context_destroy(struct pipe_context *_pipe)
1311 {
1312    struct trace_context *tr_ctx = trace_context(_pipe);
1313    struct pipe_context *pipe = tr_ctx->pipe;
1314
1315    trace_dump_call_begin("pipe_context", "destroy");
1316    trace_dump_arg(ptr, pipe);
1317    trace_dump_call_end();
1318
1319    pipe->destroy(pipe);
1320
1321    FREE(tr_ctx);
1322 }
1323
1324
1325 /********************************************************************
1326  * transfer
1327  */
1328
1329
1330 static void *
1331 trace_context_transfer_map(struct pipe_context *_context,
1332                            struct pipe_resource *_resource,
1333                            unsigned level,
1334                            unsigned usage,
1335                            const struct pipe_box *box,
1336                            struct pipe_transfer **transfer)
1337 {
1338    struct trace_context *tr_context = trace_context(_context);
1339    struct trace_resource *tr_res = trace_resource(_resource);
1340    struct pipe_context *context = tr_context->pipe;
1341    struct pipe_resource *texture = tr_res->resource;
1342    struct pipe_transfer *result = NULL;
1343    void *map;
1344
1345    assert(texture->screen == context->screen);
1346
1347    /*
1348     * Map and transfers can't be serialized so we convert all write transfers
1349     * to transfer_inline_write and ignore read transfers.
1350     */
1351
1352    map = context->transfer_map(context, texture, level, usage, box, &result);
1353    if (!map)
1354       return NULL;
1355
1356    *transfer = trace_transfer_create(tr_context, tr_res, result);
1357
1358    if (map) {
1359       if(usage & PIPE_TRANSFER_WRITE) {
1360          trace_transfer(*transfer)->map = map;
1361       }
1362    }
1363
1364    return *transfer ? map : NULL;
1365 }
1366
1367 static void
1368 trace_context_transfer_flush_region( struct pipe_context *_context,
1369                                      struct pipe_transfer *_transfer,
1370                                      const struct pipe_box *box)
1371 {
1372    struct trace_context *tr_context = trace_context(_context);
1373    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1374    struct pipe_context *context = tr_context->pipe;
1375    struct pipe_transfer *transfer = tr_transfer->transfer;
1376
1377    context->transfer_flush_region(context,
1378                                   transfer,
1379                                   box);
1380 }
1381
1382 static void
1383 trace_context_transfer_unmap(struct pipe_context *_context,
1384                              struct pipe_transfer *_transfer)
1385 {
1386    struct trace_context *tr_ctx = trace_context(_context);
1387    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1388    struct pipe_context *context = tr_ctx->pipe;
1389    struct pipe_transfer *transfer = tr_trans->transfer;
1390
1391    if(tr_trans->map) {
1392       /*
1393        * Fake a transfer_inline_write
1394        */
1395
1396       struct pipe_resource *resource = transfer->resource;
1397       unsigned level = transfer->level;
1398       unsigned usage = transfer->usage;
1399       const struct pipe_box *box = &transfer->box;
1400       unsigned stride = transfer->stride;
1401       unsigned layer_stride = transfer->layer_stride;
1402
1403       trace_dump_call_begin("pipe_context", "transfer_inline_write");
1404
1405       trace_dump_arg(ptr, context);
1406       trace_dump_arg(ptr, resource);
1407       trace_dump_arg(uint, level);
1408       trace_dump_arg(uint, usage);
1409       trace_dump_arg(box, box);
1410
1411       trace_dump_arg_begin("data");
1412       trace_dump_box_bytes(tr_trans->map,
1413                            resource->format,
1414                            box,
1415                            stride,
1416                            layer_stride);
1417       trace_dump_arg_end();
1418
1419       trace_dump_arg(uint, stride);
1420       trace_dump_arg(uint, layer_stride);
1421
1422       trace_dump_call_end();
1423
1424       tr_trans->map = NULL;
1425    }
1426
1427    context->transfer_unmap(context, transfer);
1428    trace_transfer_destroy(tr_ctx, tr_trans);
1429 }
1430
1431
1432 static void
1433 trace_context_transfer_inline_write(struct pipe_context *_context,
1434                                     struct pipe_resource *_resource,
1435                                     unsigned level,
1436                                     unsigned usage,
1437                                     const struct pipe_box *box,
1438                                     const void *data,
1439                                     unsigned stride,
1440                                     unsigned layer_stride)
1441 {
1442    struct trace_context *tr_context = trace_context(_context);
1443    struct trace_resource *tr_res = trace_resource(_resource);
1444    struct pipe_context *context = tr_context->pipe;
1445    struct pipe_resource *resource = tr_res->resource;
1446
1447    assert(resource->screen == context->screen);
1448
1449    trace_dump_call_begin("pipe_context", "transfer_inline_write");
1450
1451    trace_dump_arg(ptr, context);
1452    trace_dump_arg(ptr, resource);
1453    trace_dump_arg(uint, level);
1454    trace_dump_arg(uint, usage);
1455    trace_dump_arg(box, box);
1456
1457    trace_dump_arg_begin("data");
1458    trace_dump_box_bytes(data,
1459                         resource->format,
1460                         box,
1461                         stride,
1462                         layer_stride);
1463    trace_dump_arg_end();
1464
1465    trace_dump_arg(uint, stride);
1466    trace_dump_arg(uint, layer_stride);
1467
1468    trace_dump_call_end();
1469
1470    context->transfer_inline_write(context, resource,
1471                                   level, usage, box, data, stride, layer_stride);
1472 }
1473
1474
1475 static void trace_context_render_condition(struct pipe_context *_context,
1476                                            struct pipe_query *query,
1477                                            uint mode)
1478 {
1479    struct trace_context *tr_context = trace_context(_context);
1480    struct pipe_context *context = tr_context->pipe;
1481
1482    trace_dump_call_begin("pipe_context", "render_condition");
1483
1484    trace_dump_arg(ptr, context);
1485    trace_dump_arg(ptr, query);
1486    trace_dump_arg(uint, mode);
1487
1488    trace_dump_call_end();
1489
1490    context->render_condition(context, query, mode);
1491 }
1492
1493
1494 static void trace_context_texture_barrier(struct pipe_context *_context)
1495 {
1496    struct trace_context *tr_context = trace_context(_context);
1497    struct pipe_context *context = tr_context->pipe;
1498
1499    trace_dump_call_begin("pipe_context", "texture_barrier");
1500
1501    trace_dump_arg(ptr, context);
1502
1503    trace_dump_call_end();
1504
1505    context->texture_barrier(context);
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_fragment_sampler_states);
1551    TR_CTX_INIT(bind_vertex_sampler_states);
1552    TR_CTX_INIT(bind_geometry_sampler_states);
1553    TR_CTX_INIT(delete_sampler_state);
1554    TR_CTX_INIT(create_rasterizer_state);
1555    TR_CTX_INIT(bind_rasterizer_state);
1556    TR_CTX_INIT(delete_rasterizer_state);
1557    TR_CTX_INIT(create_depth_stencil_alpha_state);
1558    TR_CTX_INIT(bind_depth_stencil_alpha_state);
1559    TR_CTX_INIT(delete_depth_stencil_alpha_state);
1560    TR_CTX_INIT(create_fs_state);
1561    TR_CTX_INIT(bind_fs_state);
1562    TR_CTX_INIT(delete_fs_state);
1563    TR_CTX_INIT(create_vs_state);
1564    TR_CTX_INIT(bind_vs_state);
1565    TR_CTX_INIT(delete_vs_state);
1566    TR_CTX_INIT(create_gs_state);
1567    TR_CTX_INIT(bind_gs_state);
1568    TR_CTX_INIT(delete_gs_state);
1569    TR_CTX_INIT(create_vertex_elements_state);
1570    TR_CTX_INIT(bind_vertex_elements_state);
1571    TR_CTX_INIT(delete_vertex_elements_state);
1572    TR_CTX_INIT(set_blend_color);
1573    TR_CTX_INIT(set_stencil_ref);
1574    TR_CTX_INIT(set_clip_state);
1575    TR_CTX_INIT(set_sample_mask);
1576    TR_CTX_INIT(set_constant_buffer);
1577    TR_CTX_INIT(set_framebuffer_state);
1578    TR_CTX_INIT(set_polygon_stipple);
1579    TR_CTX_INIT(set_scissor_state);
1580    TR_CTX_INIT(set_viewport_state);
1581    TR_CTX_INIT(set_fragment_sampler_views);
1582    TR_CTX_INIT(set_vertex_sampler_views);
1583    TR_CTX_INIT(set_geometry_sampler_views);
1584    TR_CTX_INIT(create_sampler_view);
1585    TR_CTX_INIT(sampler_view_destroy);
1586    TR_CTX_INIT(create_surface);
1587    TR_CTX_INIT(surface_destroy);
1588    TR_CTX_INIT(set_vertex_buffers);
1589    TR_CTX_INIT(set_index_buffer);
1590    TR_CTX_INIT(create_stream_output_target);
1591    TR_CTX_INIT(stream_output_target_destroy);
1592    TR_CTX_INIT(set_stream_output_targets);
1593    TR_CTX_INIT(resource_copy_region);
1594    TR_CTX_INIT(blit);
1595    TR_CTX_INIT(clear);
1596    TR_CTX_INIT(clear_render_target);
1597    TR_CTX_INIT(clear_depth_stencil);
1598    TR_CTX_INIT(flush);
1599    TR_CTX_INIT(texture_barrier);
1600
1601    TR_CTX_INIT(transfer_map);
1602    TR_CTX_INIT(transfer_unmap);
1603    TR_CTX_INIT(transfer_flush_region);
1604    TR_CTX_INIT(transfer_inline_write);
1605
1606 #undef TR_CTX_INIT
1607
1608    tr_ctx->pipe = pipe;
1609
1610    return &tr_ctx->base;
1611
1612 error1:
1613    return pipe;
1614 }
1615
1616
1617 /**
1618  * Sanity checker: check that the given context really is a
1619  * trace context (and not the wrapped driver's context).
1620  */
1621 void
1622 trace_context_check(const struct pipe_context *pipe)
1623 {
1624    struct trace_context *tr_ctx = (struct trace_context *) pipe;
1625    assert(tr_ctx->base.destroy == trace_context_destroy);
1626 }
1627