src/gallium/drivers/trace/tr_context.c

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