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