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