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_call_end();
1104
1105    return result;
1106 }
1107
1108
1109 static INLINE void
1110 trace_context_stream_output_target_destroy(
1111    struct pipe_context *_pipe,
1112    struct pipe_stream_output_target *target)
1113 {
1114    struct trace_context *tr_ctx = trace_context(_pipe);
1115    struct pipe_context *pipe = tr_ctx->pipe;
1116
1117    trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1118
1119    trace_dump_arg(ptr, pipe);
1120    trace_dump_arg(ptr, target);
1121
1122    pipe->stream_output_target_destroy(pipe, target);
1123
1124    trace_dump_call_end();
1125 }
1126
1127
1128 static INLINE void
1129 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1130                                         unsigned num_targets,
1131                                         struct pipe_stream_output_target **tgs,
1132                                         unsigned append_bitmask)
1133 {
1134    struct trace_context *tr_ctx = trace_context(_pipe);
1135    struct pipe_context *pipe = tr_ctx->pipe;
1136
1137    trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1138
1139    trace_dump_arg(ptr, pipe);
1140    trace_dump_arg(uint, num_targets);
1141    trace_dump_arg_array(ptr, tgs, num_targets);
1142    trace_dump_arg(uint, append_bitmask);
1143
1144    pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask);
1145
1146    trace_dump_call_end();
1147 }
1148
1149
1150 static INLINE void
1151 trace_context_resource_copy_region(struct pipe_context *_pipe,
1152                                    struct pipe_resource *dst,
1153                                    unsigned dst_level,
1154                                    unsigned dstx, unsigned dsty, unsigned dstz,
1155                                    struct pipe_resource *src,
1156                                    unsigned src_level,
1157                                    const struct pipe_box *src_box)
1158 {
1159    struct trace_context *tr_ctx = trace_context(_pipe);
1160    struct pipe_context *pipe = tr_ctx->pipe;
1161
1162    dst = trace_resource_unwrap(tr_ctx, dst);
1163    src = trace_resource_unwrap(tr_ctx, src);
1164
1165    trace_dump_call_begin("pipe_context", "resource_copy_region");
1166
1167    trace_dump_arg(ptr, pipe);
1168    trace_dump_arg(ptr, dst);
1169    trace_dump_arg(uint, dst_level);
1170    trace_dump_arg(uint, dstx);
1171    trace_dump_arg(uint, dsty);
1172    trace_dump_arg(uint, dstz);
1173    trace_dump_arg(ptr, src);
1174    trace_dump_arg(uint, src_level);
1175    trace_dump_arg(box, src_box);
1176
1177    pipe->resource_copy_region(pipe,
1178                               dst, dst_level, dstx, dsty, dstz,
1179                               src, src_level, src_box);
1180
1181    trace_dump_call_end();
1182 }
1183
1184
1185 static INLINE void
1186 trace_context_blit(struct pipe_context *_pipe,
1187                    const struct pipe_blit_info *_info)
1188 {
1189    struct trace_context *tr_ctx = trace_context(_pipe);
1190    struct pipe_context *pipe = tr_ctx->pipe;
1191    struct pipe_blit_info info = *_info;
1192
1193    info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
1194    info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
1195
1196    trace_dump_call_begin("pipe_context", "blit");
1197
1198    trace_dump_arg(ptr, pipe);
1199    trace_dump_arg(blit_info, _info);
1200
1201    pipe->blit(pipe, &info);
1202
1203    trace_dump_call_end();
1204 }
1205
1206
1207 static INLINE void
1208 trace_context_clear(struct pipe_context *_pipe,
1209                     unsigned buffers,
1210                     const union pipe_color_union *color,
1211                     double depth,
1212                     unsigned stencil)
1213 {
1214    struct trace_context *tr_ctx = trace_context(_pipe);
1215    struct pipe_context *pipe = tr_ctx->pipe;
1216
1217    trace_dump_call_begin("pipe_context", "clear");
1218
1219    trace_dump_arg(ptr, pipe);
1220    trace_dump_arg(uint, buffers);
1221    trace_dump_arg_begin("color");
1222    if (color)
1223       trace_dump_array(float, color->f, 4);
1224    else
1225       trace_dump_null();
1226    trace_dump_arg_end();
1227    trace_dump_arg(float, depth);
1228    trace_dump_arg(uint, stencil);
1229
1230    pipe->clear(pipe, buffers, color, depth, stencil);
1231
1232    trace_dump_call_end();
1233 }
1234
1235
1236 static INLINE void
1237 trace_context_clear_render_target(struct pipe_context *_pipe,
1238                                   struct pipe_surface *dst,
1239                                   const union pipe_color_union *color,
1240                                   unsigned dstx, unsigned dsty,
1241                                   unsigned width, unsigned height)
1242 {
1243    struct trace_context *tr_ctx = trace_context(_pipe);
1244    struct pipe_context *pipe = tr_ctx->pipe;
1245
1246    dst = trace_surface_unwrap(tr_ctx, dst);
1247
1248    trace_dump_call_begin("pipe_context", "clear_render_target");
1249
1250    trace_dump_arg(ptr, pipe);
1251    trace_dump_arg(ptr, dst);
1252    trace_dump_arg_array(float, color->f, 4);
1253    trace_dump_arg(uint, dstx);
1254    trace_dump_arg(uint, dsty);
1255    trace_dump_arg(uint, width);
1256    trace_dump_arg(uint, height);
1257
1258    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
1259
1260    trace_dump_call_end();
1261 }
1262
1263 static INLINE void
1264 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1265                                   struct pipe_surface *dst,
1266                                   unsigned clear_flags,
1267                                   double depth,
1268                                   unsigned stencil,
1269                                   unsigned dstx, unsigned dsty,
1270                                   unsigned width, unsigned height)
1271 {
1272    struct trace_context *tr_ctx = trace_context(_pipe);
1273    struct pipe_context *pipe = tr_ctx->pipe;
1274
1275    dst = trace_surface_unwrap(tr_ctx, dst);
1276
1277    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1278
1279    trace_dump_arg(ptr, pipe);
1280    trace_dump_arg(ptr, dst);
1281    trace_dump_arg(uint, clear_flags);
1282    trace_dump_arg(float, depth);
1283    trace_dump_arg(uint, stencil);
1284    trace_dump_arg(uint, dstx);
1285    trace_dump_arg(uint, dsty);
1286    trace_dump_arg(uint, width);
1287    trace_dump_arg(uint, height);
1288
1289    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1290                              dstx, dsty, width, height);
1291
1292    trace_dump_call_end();
1293 }
1294
1295 static INLINE void
1296 trace_context_flush(struct pipe_context *_pipe,
1297                     struct pipe_fence_handle **fence,
1298                     unsigned flags)
1299 {
1300    struct trace_context *tr_ctx = trace_context(_pipe);
1301    struct pipe_context *pipe = tr_ctx->pipe;
1302
1303    trace_dump_call_begin("pipe_context", "flush");
1304
1305    trace_dump_arg(ptr, pipe);
1306    trace_dump_arg(uint, flags);
1307
1308    pipe->flush(pipe, fence, flags);
1309
1310    if(fence)
1311       trace_dump_ret(ptr, *fence);
1312
1313    trace_dump_call_end();
1314 }
1315
1316
1317 static INLINE void
1318 trace_context_destroy(struct pipe_context *_pipe)
1319 {
1320    struct trace_context *tr_ctx = trace_context(_pipe);
1321    struct pipe_context *pipe = tr_ctx->pipe;
1322
1323    trace_dump_call_begin("pipe_context", "destroy");
1324    trace_dump_arg(ptr, pipe);
1325    trace_dump_call_end();
1326
1327    pipe->destroy(pipe);
1328
1329    FREE(tr_ctx);
1330 }
1331
1332
1333 /********************************************************************
1334  * transfer
1335  */
1336
1337
1338 static void *
1339 trace_context_transfer_map(struct pipe_context *_context,
1340                            struct pipe_resource *_resource,
1341                            unsigned level,
1342                            unsigned usage,
1343                            const struct pipe_box *box,
1344                            struct pipe_transfer **transfer)
1345 {
1346    struct trace_context *tr_context = trace_context(_context);
1347    struct trace_resource *tr_res = trace_resource(_resource);
1348    struct pipe_context *context = tr_context->pipe;
1349    struct pipe_resource *texture = tr_res->resource;
1350    struct pipe_transfer *result = NULL;
1351    void *map;
1352
1353    assert(texture->screen == context->screen);
1354
1355    /*
1356     * Map and transfers can't be serialized so we convert all write transfers
1357     * to transfer_inline_write and ignore read transfers.
1358     */
1359
1360    map = context->transfer_map(context, texture, level, usage, box, &result);
1361    if (!map)
1362       return NULL;
1363
1364    *transfer = trace_transfer_create(tr_context, tr_res, result);
1365
1366    if (map) {
1367       if(usage & PIPE_TRANSFER_WRITE) {
1368          trace_transfer(*transfer)->map = map;
1369       }
1370    }
1371
1372    return *transfer ? map : NULL;
1373 }
1374
1375 static void
1376 trace_context_transfer_flush_region( struct pipe_context *_context,
1377                                      struct pipe_transfer *_transfer,
1378                                      const struct pipe_box *box)
1379 {
1380    struct trace_context *tr_context = trace_context(_context);
1381    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1382    struct pipe_context *context = tr_context->pipe;
1383    struct pipe_transfer *transfer = tr_transfer->transfer;
1384
1385    context->transfer_flush_region(context,
1386                                   transfer,
1387                                   box);
1388 }
1389
1390 static void
1391 trace_context_transfer_unmap(struct pipe_context *_context,
1392                              struct pipe_transfer *_transfer)
1393 {
1394    struct trace_context *tr_ctx = trace_context(_context);
1395    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1396    struct pipe_context *context = tr_ctx->pipe;
1397    struct pipe_transfer *transfer = tr_trans->transfer;
1398
1399    if(tr_trans->map) {
1400       /*
1401        * Fake a transfer_inline_write
1402        */
1403
1404       struct pipe_resource *resource = transfer->resource;
1405       unsigned level = transfer->level;
1406       unsigned usage = transfer->usage;
1407       const struct pipe_box *box = &transfer->box;
1408       unsigned stride = transfer->stride;
1409       unsigned layer_stride = transfer->layer_stride;
1410
1411       trace_dump_call_begin("pipe_context", "transfer_inline_write");
1412
1413       trace_dump_arg(ptr, context);
1414       trace_dump_arg(ptr, resource);
1415       trace_dump_arg(uint, level);
1416       trace_dump_arg(uint, usage);
1417       trace_dump_arg(box, box);
1418
1419       trace_dump_arg_begin("data");
1420       trace_dump_box_bytes(tr_trans->map,
1421                            resource->format,
1422                            box,
1423                            stride,
1424                            layer_stride);
1425       trace_dump_arg_end();
1426
1427       trace_dump_arg(uint, stride);
1428       trace_dump_arg(uint, layer_stride);
1429
1430       trace_dump_call_end();
1431
1432       tr_trans->map = NULL;
1433    }
1434
1435    context->transfer_unmap(context, transfer);
1436    trace_transfer_destroy(tr_ctx, tr_trans);
1437 }
1438
1439
1440 static void
1441 trace_context_transfer_inline_write(struct pipe_context *_context,
1442                                     struct pipe_resource *_resource,
1443                                     unsigned level,
1444                                     unsigned usage,
1445                                     const struct pipe_box *box,
1446                                     const void *data,
1447                                     unsigned stride,
1448                                     unsigned layer_stride)
1449 {
1450    struct trace_context *tr_context = trace_context(_context);
1451    struct trace_resource *tr_res = trace_resource(_resource);
1452    struct pipe_context *context = tr_context->pipe;
1453    struct pipe_resource *resource = tr_res->resource;
1454
1455    assert(resource->screen == context->screen);
1456
1457    trace_dump_call_begin("pipe_context", "transfer_inline_write");
1458
1459    trace_dump_arg(ptr, context);
1460    trace_dump_arg(ptr, resource);
1461    trace_dump_arg(uint, level);
1462    trace_dump_arg(uint, usage);
1463    trace_dump_arg(box, box);
1464
1465    trace_dump_arg_begin("data");
1466    trace_dump_box_bytes(data,
1467                         resource->format,
1468                         box,
1469                         stride,
1470                         layer_stride);
1471    trace_dump_arg_end();
1472
1473    trace_dump_arg(uint, stride);
1474    trace_dump_arg(uint, layer_stride);
1475
1476    trace_dump_call_end();
1477
1478    context->transfer_inline_write(context, resource,
1479                                   level, usage, box, data, stride, layer_stride);
1480 }
1481
1482
1483 static void trace_context_render_condition(struct pipe_context *_context,
1484                                            struct pipe_query *query,
1485                                            uint mode)
1486 {
1487    struct trace_context *tr_context = trace_context(_context);
1488    struct pipe_context *context = tr_context->pipe;
1489
1490    trace_dump_call_begin("pipe_context", "render_condition");
1491
1492    trace_dump_arg(ptr, context);
1493    trace_dump_arg(ptr, query);
1494    trace_dump_arg(uint, mode);
1495
1496    trace_dump_call_end();
1497
1498    context->render_condition(context, query, mode);
1499 }
1500
1501
1502 static void trace_context_texture_barrier(struct pipe_context *_context)
1503 {
1504    struct trace_context *tr_context = trace_context(_context);
1505    struct pipe_context *context = tr_context->pipe;
1506
1507    trace_dump_call_begin("pipe_context", "texture_barrier");
1508
1509    trace_dump_arg(ptr, context);
1510
1511    trace_dump_call_end();
1512
1513    context->texture_barrier(context);
1514 }
1515
1516
1517 static const struct debug_named_value rbug_blocker_flags[] = {
1518    {"before", 1, NULL},
1519    {"after", 2, NULL},
1520    DEBUG_NAMED_VALUE_END
1521 };
1522
1523 struct pipe_context *
1524 trace_context_create(struct trace_screen *tr_scr,
1525                      struct pipe_context *pipe)
1526 {
1527    struct trace_context *tr_ctx;
1528
1529    if(!pipe)
1530       goto error1;
1531
1532    if(!trace_enabled())
1533       goto error1;
1534
1535    tr_ctx = CALLOC_STRUCT(trace_context);
1536    if(!tr_ctx)
1537       goto error1;
1538
1539    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1540    tr_ctx->base.screen = &tr_scr->base;
1541
1542    tr_ctx->base.destroy = trace_context_destroy;
1543
1544 #define TR_CTX_INIT(_member) \
1545    tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1546
1547    TR_CTX_INIT(draw_vbo);
1548    TR_CTX_INIT(render_condition);
1549    TR_CTX_INIT(create_query);
1550    TR_CTX_INIT(destroy_query);
1551    TR_CTX_INIT(begin_query);
1552    TR_CTX_INIT(end_query);
1553    TR_CTX_INIT(get_query_result);
1554    TR_CTX_INIT(create_blend_state);
1555    TR_CTX_INIT(bind_blend_state);
1556    TR_CTX_INIT(delete_blend_state);
1557    TR_CTX_INIT(create_sampler_state);
1558    TR_CTX_INIT(bind_fragment_sampler_states);
1559    TR_CTX_INIT(bind_vertex_sampler_states);
1560    TR_CTX_INIT(bind_geometry_sampler_states);
1561    TR_CTX_INIT(delete_sampler_state);
1562    TR_CTX_INIT(create_rasterizer_state);
1563    TR_CTX_INIT(bind_rasterizer_state);
1564    TR_CTX_INIT(delete_rasterizer_state);
1565    TR_CTX_INIT(create_depth_stencil_alpha_state);
1566    TR_CTX_INIT(bind_depth_stencil_alpha_state);
1567    TR_CTX_INIT(delete_depth_stencil_alpha_state);
1568    TR_CTX_INIT(create_fs_state);
1569    TR_CTX_INIT(bind_fs_state);
1570    TR_CTX_INIT(delete_fs_state);
1571    TR_CTX_INIT(create_vs_state);
1572    TR_CTX_INIT(bind_vs_state);
1573    TR_CTX_INIT(delete_vs_state);
1574    TR_CTX_INIT(create_gs_state);
1575    TR_CTX_INIT(bind_gs_state);
1576    TR_CTX_INIT(delete_gs_state);
1577    TR_CTX_INIT(create_vertex_elements_state);
1578    TR_CTX_INIT(bind_vertex_elements_state);
1579    TR_CTX_INIT(delete_vertex_elements_state);
1580    TR_CTX_INIT(set_blend_color);
1581    TR_CTX_INIT(set_stencil_ref);
1582    TR_CTX_INIT(set_clip_state);
1583    TR_CTX_INIT(set_sample_mask);
1584    TR_CTX_INIT(set_constant_buffer);
1585    TR_CTX_INIT(set_framebuffer_state);
1586    TR_CTX_INIT(set_polygon_stipple);
1587    TR_CTX_INIT(set_scissor_states);
1588    TR_CTX_INIT(set_viewport_states);
1589    TR_CTX_INIT(set_fragment_sampler_views);
1590    TR_CTX_INIT(set_vertex_sampler_views);
1591    TR_CTX_INIT(set_geometry_sampler_views);
1592    TR_CTX_INIT(create_sampler_view);
1593    TR_CTX_INIT(sampler_view_destroy);
1594    TR_CTX_INIT(create_surface);
1595    TR_CTX_INIT(surface_destroy);
1596    TR_CTX_INIT(set_vertex_buffers);
1597    TR_CTX_INIT(set_index_buffer);
1598    TR_CTX_INIT(create_stream_output_target);
1599    TR_CTX_INIT(stream_output_target_destroy);
1600    TR_CTX_INIT(set_stream_output_targets);
1601    TR_CTX_INIT(resource_copy_region);
1602    TR_CTX_INIT(blit);
1603    TR_CTX_INIT(clear);
1604    TR_CTX_INIT(clear_render_target);
1605    TR_CTX_INIT(clear_depth_stencil);
1606    TR_CTX_INIT(flush);
1607    TR_CTX_INIT(texture_barrier);
1608
1609    TR_CTX_INIT(transfer_map);
1610    TR_CTX_INIT(transfer_unmap);
1611    TR_CTX_INIT(transfer_flush_region);
1612    TR_CTX_INIT(transfer_inline_write);
1613
1614 #undef TR_CTX_INIT
1615
1616    tr_ctx->pipe = pipe;
1617
1618    return &tr_ctx->base;
1619
1620 error1:
1621    return pipe;
1622 }
1623
1624
1625 /**
1626  * Sanity checker: check that the given context really is a
1627  * trace context (and not the wrapped driver's context).
1628  */
1629 void
1630 trace_context_check(const struct pipe_context *pipe)
1631 {
1632    struct trace_context *tr_ctx = (struct trace_context *) pipe;
1633    assert(tr_ctx->base.destroy == trace_context_destroy);
1634 }
1635