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