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 {
  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 boolean
 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    boolean 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 boolean
 215 trace_context_get_query_result(struct pipe_context *_pipe,
 216                                struct pipe_query *_query,
 217                                boolean 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    boolean 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                                      boolean 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 void
1038 trace_context_set_index_buffer(struct pipe_context *_pipe,
1039                                const struct pipe_index_buffer *ib)
1040 {
1041    struct trace_context *tr_ctx = trace_context(_pipe);
1042    struct pipe_context *pipe = tr_ctx->pipe;
1043
1044    trace_dump_call_begin("pipe_context", "set_index_buffer");
1045
1046    trace_dump_arg(ptr, pipe);
1047    trace_dump_arg(index_buffer, ib);
1048
1049    pipe->set_index_buffer(pipe, ib);
1050
1051    trace_dump_call_end();
1052 }
1053
1054
1055 static struct pipe_stream_output_target *
1056 trace_context_create_stream_output_target(struct pipe_context *_pipe,
1057                                           struct pipe_resource *res,
1058                                           unsigned buffer_offset,
1059                                           unsigned buffer_size)
1060 {
1061    struct trace_context *tr_ctx = trace_context(_pipe);
1062    struct pipe_context *pipe = tr_ctx->pipe;
1063    struct pipe_stream_output_target *result;
1064
1065    trace_dump_call_begin("pipe_context", "create_stream_output_target");
1066
1067    trace_dump_arg(ptr, pipe);
1068    trace_dump_arg(ptr, res);
1069    trace_dump_arg(uint, buffer_offset);
1070    trace_dump_arg(uint, buffer_size);
1071
1072    result = pipe->create_stream_output_target(pipe,
1073                                               res, buffer_offset, buffer_size);
1074
1075    trace_dump_ret(ptr, result);
1076
1077    trace_dump_call_end();
1078
1079    return result;
1080 }
1081
1082
1083 static void
1084 trace_context_stream_output_target_destroy(
1085    struct pipe_context *_pipe,
1086    struct pipe_stream_output_target *target)
1087 {
1088    struct trace_context *tr_ctx = trace_context(_pipe);
1089    struct pipe_context *pipe = tr_ctx->pipe;
1090
1091    trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1092
1093    trace_dump_arg(ptr, pipe);
1094    trace_dump_arg(ptr, target);
1095
1096    pipe->stream_output_target_destroy(pipe, target);
1097
1098    trace_dump_call_end();
1099 }
1100
1101
1102 static void
1103 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1104                                         unsigned num_targets,
1105                                         struct pipe_stream_output_target **tgs,
1106                                         const unsigned *offsets)
1107 {
1108    struct trace_context *tr_ctx = trace_context(_pipe);
1109    struct pipe_context *pipe = tr_ctx->pipe;
1110
1111    trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1112
1113    trace_dump_arg(ptr, pipe);
1114    trace_dump_arg(uint, num_targets);
1115    trace_dump_arg_array(ptr, tgs, num_targets);
1116    trace_dump_arg_array(uint, offsets, num_targets);
1117
1118    pipe->set_stream_output_targets(pipe, num_targets, tgs, offsets);
1119
1120    trace_dump_call_end();
1121 }
1122
1123
1124 static void
1125 trace_context_resource_copy_region(struct pipe_context *_pipe,
1126                                    struct pipe_resource *dst,
1127                                    unsigned dst_level,
1128                                    unsigned dstx, unsigned dsty, unsigned dstz,
1129                                    struct pipe_resource *src,
1130                                    unsigned src_level,
1131                                    const struct pipe_box *src_box)
1132 {
1133    struct trace_context *tr_ctx = trace_context(_pipe);
1134    struct pipe_context *pipe = tr_ctx->pipe;
1135
1136    trace_dump_call_begin("pipe_context", "resource_copy_region");
1137
1138    trace_dump_arg(ptr, pipe);
1139    trace_dump_arg(ptr, dst);
1140    trace_dump_arg(uint, dst_level);
1141    trace_dump_arg(uint, dstx);
1142    trace_dump_arg(uint, dsty);
1143    trace_dump_arg(uint, dstz);
1144    trace_dump_arg(ptr, src);
1145    trace_dump_arg(uint, src_level);
1146    trace_dump_arg(box, src_box);
1147
1148    pipe->resource_copy_region(pipe,
1149                               dst, dst_level, dstx, dsty, dstz,
1150                               src, src_level, src_box);
1151
1152    trace_dump_call_end();
1153 }
1154
1155
1156 static void
1157 trace_context_blit(struct pipe_context *_pipe,
1158                    const struct pipe_blit_info *_info)
1159 {
1160    struct trace_context *tr_ctx = trace_context(_pipe);
1161    struct pipe_context *pipe = tr_ctx->pipe;
1162    struct pipe_blit_info info = *_info;
1163
1164    trace_dump_call_begin("pipe_context", "blit");
1165
1166    trace_dump_arg(ptr, pipe);
1167    trace_dump_arg(blit_info, _info);
1168
1169    pipe->blit(pipe, &info);
1170
1171    trace_dump_call_end();
1172 }
1173
1174
1175 static void
1176 trace_context_flush_resource(struct pipe_context *_pipe,
1177                              struct pipe_resource *resource)
1178 {
1179    struct trace_context *tr_ctx = trace_context(_pipe);
1180    struct pipe_context *pipe = tr_ctx->pipe;
1181
1182    trace_dump_call_begin("pipe_context", "flush_resource");
1183
1184    trace_dump_arg(ptr, pipe);
1185    trace_dump_arg(ptr, resource);
1186
1187    pipe->flush_resource(pipe, resource);
1188
1189    trace_dump_call_end();
1190 }
1191
1192
1193 static void
1194 trace_context_clear(struct pipe_context *_pipe,
1195                     unsigned buffers,
1196                     const union pipe_color_union *color,
1197                     double depth,
1198                     unsigned stencil)
1199 {
1200    struct trace_context *tr_ctx = trace_context(_pipe);
1201    struct pipe_context *pipe = tr_ctx->pipe;
1202
1203    trace_dump_call_begin("pipe_context", "clear");
1204
1205    trace_dump_arg(ptr, pipe);
1206    trace_dump_arg(uint, buffers);
1207    trace_dump_arg_begin("color");
1208    if (color)
1209       trace_dump_array(float, color->f, 4);
1210    else
1211       trace_dump_null();
1212    trace_dump_arg_end();
1213    trace_dump_arg(float, depth);
1214    trace_dump_arg(uint, stencil);
1215
1216    pipe->clear(pipe, buffers, color, depth, stencil);
1217
1218    trace_dump_call_end();
1219 }
1220
1221
1222 static void
1223 trace_context_clear_render_target(struct pipe_context *_pipe,
1224                                   struct pipe_surface *dst,
1225                                   const union pipe_color_union *color,
1226                                   unsigned dstx, unsigned dsty,
1227                                   unsigned width, unsigned height,
1228                                   bool render_condition_enabled)
1229 {
1230    struct trace_context *tr_ctx = trace_context(_pipe);
1231    struct pipe_context *pipe = tr_ctx->pipe;
1232
1233    dst = trace_surface_unwrap(tr_ctx, dst);
1234
1235    trace_dump_call_begin("pipe_context", "clear_render_target");
1236
1237    trace_dump_arg(ptr, pipe);
1238    trace_dump_arg(ptr, dst);
1239    trace_dump_arg_array(float, color->f, 4);
1240    trace_dump_arg(uint, dstx);
1241    trace_dump_arg(uint, dsty);
1242    trace_dump_arg(uint, width);
1243    trace_dump_arg(uint, height);
1244    trace_dump_arg(bool, render_condition_enabled);
1245
1246    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height,
1247                              render_condition_enabled);
1248
1249    trace_dump_call_end();
1250 }
1251
1252 static void
1253 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1254                                   struct pipe_surface *dst,
1255                                   unsigned clear_flags,
1256                                   double depth,
1257                                   unsigned stencil,
1258                                   unsigned dstx, unsigned dsty,
1259                                   unsigned width, unsigned height,
1260                                   bool render_condition_enabled)
1261 {
1262    struct trace_context *tr_ctx = trace_context(_pipe);
1263    struct pipe_context *pipe = tr_ctx->pipe;
1264
1265    dst = trace_surface_unwrap(tr_ctx, dst);
1266
1267    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1268
1269    trace_dump_arg(ptr, pipe);
1270    trace_dump_arg(ptr, dst);
1271    trace_dump_arg(uint, clear_flags);
1272    trace_dump_arg(float, depth);
1273    trace_dump_arg(uint, stencil);
1274    trace_dump_arg(uint, dstx);
1275    trace_dump_arg(uint, dsty);
1276    trace_dump_arg(uint, width);
1277    trace_dump_arg(uint, height);
1278    trace_dump_arg(bool, render_condition_enabled);
1279
1280    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1281                              dstx, dsty, width, height,
1282                              render_condition_enabled);
1283
1284    trace_dump_call_end();
1285 }
1286
1287 static inline void
1288 trace_context_clear_texture(struct pipe_context *_pipe,
1289                             struct pipe_resource *res,
1290                             unsigned level,
1291                             const struct pipe_box *box,
1292                             const void *data)
1293 {
1294    struct trace_context *tr_ctx = trace_context(_pipe);
1295    struct pipe_context *pipe = tr_ctx->pipe;
1296
1297
1298    trace_dump_call_begin("pipe_context", "clear_texture");
1299
1300    trace_dump_arg(ptr, pipe);
1301    trace_dump_arg(ptr, res);
1302    trace_dump_arg(uint, level);
1303    trace_dump_arg_begin("box");
1304    trace_dump_box(box);
1305    trace_dump_arg_end();
1306    trace_dump_arg(ptr, data);
1307
1308    pipe->clear_texture(pipe, res, level, box, data);
1309
1310    trace_dump_call_end();
1311 }
1312
1313 static void
1314 trace_context_flush(struct pipe_context *_pipe,
1315                     struct pipe_fence_handle **fence,
1316                     unsigned flags)
1317 {
1318    struct trace_context *tr_ctx = trace_context(_pipe);
1319    struct pipe_context *pipe = tr_ctx->pipe;
1320
1321    trace_dump_call_begin("pipe_context", "flush");
1322
1323    trace_dump_arg(ptr, pipe);
1324    trace_dump_arg(uint, flags);
1325
1326    pipe->flush(pipe, fence, flags);
1327
1328    if (fence)
1329       trace_dump_ret(ptr, *fence);
1330
1331    trace_dump_call_end();
1332 }
1333
1334
1335 static inline boolean
1336 trace_context_generate_mipmap(struct pipe_context *_pipe,
1337                               struct pipe_resource *res,
1338                               enum pipe_format format,
1339                               unsigned base_level,
1340                               unsigned last_level,
1341                               unsigned first_layer,
1342                               unsigned last_layer)
1343 {
1344    struct trace_context *tr_ctx = trace_context(_pipe);
1345    struct pipe_context *pipe = tr_ctx->pipe;
1346    boolean ret;
1347
1348    trace_dump_call_begin("pipe_context", "generate_mipmap");
1349
1350    trace_dump_arg(ptr, pipe);
1351    trace_dump_arg(ptr, res);
1352
1353    trace_dump_arg(format, format);
1354    trace_dump_arg(uint, base_level);
1355    trace_dump_arg(uint, last_level);
1356    trace_dump_arg(uint, first_layer);
1357    trace_dump_arg(uint, last_layer);
1358
1359    ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level,
1360                                first_layer, last_layer);
1361
1362    trace_dump_ret(bool, ret);
1363    trace_dump_call_end();
1364
1365    return ret;
1366 }
1367
1368
1369 static void
1370 trace_context_destroy(struct pipe_context *_pipe)
1371 {
1372    struct trace_context *tr_ctx = trace_context(_pipe);
1373    struct pipe_context *pipe = tr_ctx->pipe;
1374
1375    trace_dump_call_begin("pipe_context", "destroy");
1376    trace_dump_arg(ptr, pipe);
1377    trace_dump_call_end();
1378
1379    pipe->destroy(pipe);
1380
1381    FREE(tr_ctx);
1382 }
1383
1384
1385 /********************************************************************
1386  * transfer
1387  */
1388
1389
1390 static void *
1391 trace_context_transfer_map(struct pipe_context *_context,
1392                            struct pipe_resource *resource,
1393                            unsigned level,
1394                            unsigned usage,
1395                            const struct pipe_box *box,
1396                            struct pipe_transfer **transfer)
1397 {
1398    struct trace_context *tr_context = trace_context(_context);
1399    struct pipe_context *context = tr_context->pipe;
1400    struct pipe_transfer *result = NULL;
1401    void *map;
1402
1403    /*
1404     * Map and transfers can't be serialized so we convert all write transfers
1405     * to texture/buffer_subdata and ignore read transfers.
1406     */
1407
1408    map = context->transfer_map(context, resource, level, usage, box, &result);
1409    if (!map)
1410       return NULL;
1411
1412    *transfer = trace_transfer_create(tr_context, resource, result);
1413
1414    if (map) {
1415       if (usage & PIPE_TRANSFER_WRITE) {
1416          trace_transfer(*transfer)->map = map;
1417       }
1418    }
1419
1420    return *transfer ? map : NULL;
1421 }
1422
1423 static void
1424 trace_context_transfer_flush_region( struct pipe_context *_context,
1425                                      struct pipe_transfer *_transfer,
1426                                      const struct pipe_box *box)
1427 {
1428    struct trace_context *tr_context = trace_context(_context);
1429    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1430    struct pipe_context *context = tr_context->pipe;
1431    struct pipe_transfer *transfer = tr_transfer->transfer;
1432
1433    context->transfer_flush_region(context, transfer, box);
1434 }
1435
1436 static void
1437 trace_context_transfer_unmap(struct pipe_context *_context,
1438                              struct pipe_transfer *_transfer)
1439 {
1440    struct trace_context *tr_ctx = trace_context(_context);
1441    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1442    struct pipe_context *context = tr_ctx->pipe;
1443    struct pipe_transfer *transfer = tr_trans->transfer;
1444
1445    if (tr_trans->map) {
1446       /*
1447        * Fake a texture/buffer_subdata
1448        */
1449
1450       struct pipe_resource *resource = transfer->resource;
1451       unsigned level = transfer->level;
1452       unsigned usage = transfer->usage;
1453       const struct pipe_box *box = &transfer->box;
1454       unsigned stride = transfer->stride;
1455       unsigned layer_stride = transfer->layer_stride;
1456
1457       if (resource->target == PIPE_BUFFER)
1458          trace_dump_call_begin("pipe_context", "buffer_subdata");
1459       else
1460          trace_dump_call_begin("pipe_context", "texture_subdata");
1461
1462       trace_dump_arg(ptr, context);
1463       trace_dump_arg(ptr, resource);
1464       trace_dump_arg(uint, level);
1465       trace_dump_arg(uint, usage);
1466       trace_dump_arg(box, box);
1467
1468       trace_dump_arg_begin("data");
1469       trace_dump_box_bytes(tr_trans->map,
1470                            resource,
1471                            box,
1472                            stride,
1473                            layer_stride);
1474       trace_dump_arg_end();
1475
1476       trace_dump_arg(uint, stride);
1477       trace_dump_arg(uint, layer_stride);
1478
1479       trace_dump_call_end();
1480
1481       tr_trans->map = NULL;
1482    }
1483
1484    context->transfer_unmap(context, transfer);
1485    trace_transfer_destroy(tr_ctx, tr_trans);
1486 }
1487
1488
1489 static void
1490 trace_context_buffer_subdata(struct pipe_context *_context,
1491                              struct pipe_resource *resource,
1492                              unsigned usage, unsigned offset,
1493                              unsigned size, const void *data)
1494 {
1495    struct trace_context *tr_context = trace_context(_context);
1496    struct pipe_context *context = tr_context->pipe;
1497    struct pipe_box box;
1498
1499    trace_dump_call_begin("pipe_context", "buffer_subdata");
1500
1501    trace_dump_arg(ptr, context);
1502    trace_dump_arg(ptr, resource);
1503    trace_dump_arg(uint, usage);
1504    trace_dump_arg(uint, offset);
1505    trace_dump_arg(uint, size);
1506
1507    trace_dump_arg_begin("data");
1508    u_box_1d(offset, size, &box);
1509    trace_dump_box_bytes(data, resource, &box, 0, 0);
1510    trace_dump_arg_end();
1511
1512    trace_dump_call_end();
1513
1514    context->buffer_subdata(context, resource, usage, offset, size, data);
1515 }
1516
1517
1518 static void
1519 trace_context_texture_subdata(struct pipe_context *_context,
1520                               struct pipe_resource *resource,
1521                               unsigned level,
1522                               unsigned usage,
1523                               const struct pipe_box *box,
1524                               const void *data,
1525                               unsigned stride,
1526                               unsigned layer_stride)
1527 {
1528    struct trace_context *tr_context = trace_context(_context);
1529    struct pipe_context *context = tr_context->pipe;
1530
1531    trace_dump_call_begin("pipe_context", "texture_subdata");
1532
1533    trace_dump_arg(ptr, context);
1534    trace_dump_arg(ptr, resource);
1535    trace_dump_arg(uint, level);
1536    trace_dump_arg(uint, usage);
1537    trace_dump_arg(box, box);
1538
1539    trace_dump_arg_begin("data");
1540    trace_dump_box_bytes(data,
1541                         resource,
1542                         box,
1543                         stride,
1544                         layer_stride);
1545    trace_dump_arg_end();
1546
1547    trace_dump_arg(uint, stride);
1548    trace_dump_arg(uint, layer_stride);
1549
1550    trace_dump_call_end();
1551
1552    context->texture_subdata(context, resource, level, usage, box,
1553                             data, stride, layer_stride);
1554 }
1555
1556 static void
1557 trace_context_invalidate_resource(struct pipe_context *_context,
1558                                   struct pipe_resource *resource)
1559 {
1560    struct trace_context *tr_context = trace_context(_context);
1561    struct pipe_context *context = tr_context->pipe;
1562
1563    trace_dump_call_begin("pipe_context", "invalidate_resource");
1564
1565    trace_dump_arg(ptr, context);
1566    trace_dump_arg(ptr, resource);
1567
1568    trace_dump_call_end();
1569
1570    context->invalidate_resource(context, resource);
1571 }
1572
1573 static void
1574 trace_context_render_condition(struct pipe_context *_context,
1575                                struct pipe_query *query,
1576                                boolean condition,
1577                                enum pipe_render_cond_flag mode)
1578 {
1579    struct trace_context *tr_context = trace_context(_context);
1580    struct pipe_context *context = tr_context->pipe;
1581
1582    query = trace_query_unwrap(query);
1583
1584    trace_dump_call_begin("pipe_context", "render_condition");
1585
1586    trace_dump_arg(ptr, context);
1587    trace_dump_arg(ptr, query);
1588    trace_dump_arg(bool, condition);
1589    trace_dump_arg(uint, mode);
1590
1591    trace_dump_call_end();
1592
1593    context->render_condition(context, query, condition, mode);
1594 }
1595
1596
1597 static void
1598 trace_context_texture_barrier(struct pipe_context *_context, unsigned flags)
1599 {
1600    struct trace_context *tr_context = trace_context(_context);
1601    struct pipe_context *context = tr_context->pipe;
1602
1603    trace_dump_call_begin("pipe_context", "texture_barrier");
1604
1605    trace_dump_arg(ptr, context);
1606    trace_dump_arg(uint, flags);
1607
1608    trace_dump_call_end();
1609
1610    context->texture_barrier(context, flags);
1611 }
1612
1613
1614 static void
1615 trace_context_memory_barrier(struct pipe_context *_context,
1616                              unsigned flags)
1617 {
1618    struct trace_context *tr_context = trace_context(_context);
1619    struct pipe_context *context = tr_context->pipe;
1620
1621    trace_dump_call_begin("pipe_context", "memory_barrier");
1622    trace_dump_arg(ptr, context);
1623    trace_dump_arg(uint, flags);
1624    trace_dump_call_end();
1625
1626    context->memory_barrier(context, flags);
1627 }
1628
1629
1630 static void
1631 trace_context_set_tess_state(struct pipe_context *_context,
1632                              const float default_outer_level[4],
1633                              const float default_inner_level[2])
1634 {
1635    struct trace_context *tr_context = trace_context(_context);
1636    struct pipe_context *context = tr_context->pipe;
1637
1638    trace_dump_call_begin("pipe_context", "set_tess_state");
1639    trace_dump_arg(ptr, context);
1640    trace_dump_arg_array(float, default_outer_level, 4);
1641    trace_dump_arg_array(float, default_inner_level, 2);
1642    trace_dump_call_end();
1643
1644    context->set_tess_state(context, default_outer_level, default_inner_level);
1645 }
1646
1647
1648 static void trace_context_set_shader_buffers(struct pipe_context *_context,
1649                                              enum pipe_shader_type shader,
1650                                              unsigned start, unsigned nr,
1651                                              const struct pipe_shader_buffer *buffers)
1652 {
1653    struct trace_context *tr_context = trace_context(_context);
1654    struct pipe_context *context = tr_context->pipe;
1655
1656    trace_dump_call_begin("pipe_context", "set_shader_buffers");
1657    trace_dump_arg(ptr, context);
1658    trace_dump_arg(uint, shader);
1659    trace_dump_arg(uint, start);
1660    trace_dump_arg_begin("buffers");
1661    trace_dump_struct_array(shader_buffer, buffers, nr);
1662    trace_dump_arg_end();
1663    trace_dump_call_end();
1664
1665    context->set_shader_buffers(context, shader, start, nr, buffers);
1666 }
1667
1668 static void trace_context_set_shader_images(struct pipe_context *_context,
1669                                             enum pipe_shader_type shader,
1670                                             unsigned start, unsigned nr,
1671                                             const struct pipe_image_view *images)
1672 {
1673    struct trace_context *tr_context = trace_context(_context);
1674    struct pipe_context *context = tr_context->pipe;
1675
1676    trace_dump_call_begin("pipe_context", "set_shader_images");
1677    trace_dump_arg(ptr, context);
1678    trace_dump_arg(uint, shader);
1679    trace_dump_arg(uint, start);
1680    trace_dump_arg_begin("images");
1681    trace_dump_struct_array(image_view, images, nr);
1682    trace_dump_arg_end();
1683    trace_dump_call_end();
1684
1685    context->set_shader_images(context, shader, start, nr, images);
1686 }
1687
1688 static void trace_context_launch_grid(struct pipe_context *_pipe,
1689                                       const struct pipe_grid_info *info)
1690 {
1691    struct trace_context *tr_ctx = trace_context(_pipe);
1692    struct pipe_context *pipe = tr_ctx->pipe;
1693
1694    trace_dump_call_begin("pipe_context", "launch_grid");
1695
1696    trace_dump_arg(ptr,  pipe);
1697    trace_dump_arg(grid_info, info);
1698
1699    trace_dump_trace_flush();
1700
1701    pipe->launch_grid(pipe, info);
1702
1703    trace_dump_call_end();
1704 }
1705
1706 struct pipe_context *
1707 trace_context_create(struct trace_screen *tr_scr,
1708                      struct pipe_context *pipe)
1709 {
1710    struct trace_context *tr_ctx;
1711
1712    if (!pipe)
1713       goto error1;
1714
1715    if (!trace_enabled())
1716       goto error1;
1717
1718    tr_ctx = CALLOC_STRUCT(trace_context);
1719    if (!tr_ctx)
1720       goto error1;
1721
1722    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1723    tr_ctx->base.screen = &tr_scr->base;
1724    tr_ctx->base.stream_uploader = pipe->stream_uploader;
1725    tr_ctx->base.const_uploader = pipe->const_uploader;
1726
1727    tr_ctx->base.destroy = trace_context_destroy;
1728
1729 #define TR_CTX_INIT(_member) \
1730    tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1731
1732    TR_CTX_INIT(draw_vbo);
1733    TR_CTX_INIT(render_condition);
1734    TR_CTX_INIT(create_query);
1735    TR_CTX_INIT(destroy_query);
1736    TR_CTX_INIT(begin_query);
1737    TR_CTX_INIT(end_query);
1738    TR_CTX_INIT(get_query_result);
1739    TR_CTX_INIT(set_active_query_state);
1740    TR_CTX_INIT(create_blend_state);
1741    TR_CTX_INIT(bind_blend_state);
1742    TR_CTX_INIT(delete_blend_state);
1743    TR_CTX_INIT(create_sampler_state);
1744    TR_CTX_INIT(bind_sampler_states);
1745    TR_CTX_INIT(delete_sampler_state);
1746    TR_CTX_INIT(create_rasterizer_state);
1747    TR_CTX_INIT(bind_rasterizer_state);
1748    TR_CTX_INIT(delete_rasterizer_state);
1749    TR_CTX_INIT(create_depth_stencil_alpha_state);
1750    TR_CTX_INIT(bind_depth_stencil_alpha_state);
1751    TR_CTX_INIT(delete_depth_stencil_alpha_state);
1752    TR_CTX_INIT(create_fs_state);
1753    TR_CTX_INIT(bind_fs_state);
1754    TR_CTX_INIT(delete_fs_state);
1755    TR_CTX_INIT(create_vs_state);
1756    TR_CTX_INIT(bind_vs_state);
1757    TR_CTX_INIT(delete_vs_state);
1758    TR_CTX_INIT(create_gs_state);
1759    TR_CTX_INIT(bind_gs_state);
1760    TR_CTX_INIT(delete_gs_state);
1761    TR_CTX_INIT(create_tcs_state);
1762    TR_CTX_INIT(bind_tcs_state);
1763    TR_CTX_INIT(delete_tcs_state);
1764    TR_CTX_INIT(create_tes_state);
1765    TR_CTX_INIT(bind_tes_state);
1766    TR_CTX_INIT(delete_tes_state);
1767    TR_CTX_INIT(create_compute_state);
1768    TR_CTX_INIT(bind_compute_state);
1769    TR_CTX_INIT(delete_compute_state);
1770    TR_CTX_INIT(create_vertex_elements_state);
1771    TR_CTX_INIT(bind_vertex_elements_state);
1772    TR_CTX_INIT(delete_vertex_elements_state);
1773    TR_CTX_INIT(set_blend_color);
1774    TR_CTX_INIT(set_stencil_ref);
1775    TR_CTX_INIT(set_clip_state);
1776    TR_CTX_INIT(set_sample_mask);
1777    TR_CTX_INIT(set_constant_buffer);
1778    TR_CTX_INIT(set_framebuffer_state);
1779    TR_CTX_INIT(set_polygon_stipple);
1780    TR_CTX_INIT(set_scissor_states);
1781    TR_CTX_INIT(set_viewport_states);
1782    TR_CTX_INIT(set_sampler_views);
1783    TR_CTX_INIT(create_sampler_view);
1784    TR_CTX_INIT(sampler_view_destroy);
1785    TR_CTX_INIT(create_surface);
1786    TR_CTX_INIT(surface_destroy);
1787    TR_CTX_INIT(set_vertex_buffers);
1788    TR_CTX_INIT(set_index_buffer);
1789    TR_CTX_INIT(create_stream_output_target);
1790    TR_CTX_INIT(stream_output_target_destroy);
1791    TR_CTX_INIT(set_stream_output_targets);
1792    TR_CTX_INIT(resource_copy_region);
1793    TR_CTX_INIT(blit);
1794    TR_CTX_INIT(flush_resource);
1795    TR_CTX_INIT(clear);
1796    TR_CTX_INIT(clear_render_target);
1797    TR_CTX_INIT(clear_depth_stencil);
1798    TR_CTX_INIT(clear_texture);
1799    TR_CTX_INIT(flush);
1800    TR_CTX_INIT(generate_mipmap);
1801    TR_CTX_INIT(texture_barrier);
1802    TR_CTX_INIT(memory_barrier);
1803    TR_CTX_INIT(set_tess_state);
1804    TR_CTX_INIT(set_shader_buffers);
1805    TR_CTX_INIT(launch_grid);
1806    TR_CTX_INIT(set_shader_images);
1807
1808    TR_CTX_INIT(transfer_map);
1809    TR_CTX_INIT(transfer_unmap);
1810    TR_CTX_INIT(transfer_flush_region);
1811    TR_CTX_INIT(buffer_subdata);
1812    TR_CTX_INIT(texture_subdata);
1813    TR_CTX_INIT(invalidate_resource);
1814
1815 #undef TR_CTX_INIT
1816
1817    tr_ctx->pipe = pipe;
1818
1819    return &tr_ctx->base;
1820
1821 error1:
1822    return pipe;
1823 }
1824
1825
1826 /**
1827  * Sanity checker: check that the given context really is a
1828  * trace context (and not the wrapped driver's context).
1829  */
1830 void
1831 trace_context_check(const struct pipe_context *pipe)
1832 {
1833    MAYBE_UNUSED struct trace_context *tr_ctx = (struct trace_context *) pipe;
1834    assert(tr_ctx->base.destroy == trace_context_destroy);
1835 }