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 {
1296    struct trace_context *tr_ctx = trace_context(_pipe);
1297    struct pipe_context *pipe = tr_ctx->pipe;
1298
1299    dst = trace_surface_unwrap(tr_ctx, dst);
1300
1301    trace_dump_call_begin("pipe_context", "clear_render_target");
1302
1303    trace_dump_arg(ptr, pipe);
1304    trace_dump_arg(ptr, dst);
1305    trace_dump_arg_array(float, color->f, 4);
1306    trace_dump_arg(uint, dstx);
1307    trace_dump_arg(uint, dsty);
1308    trace_dump_arg(uint, width);
1309    trace_dump_arg(uint, height);
1310
1311    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
1312
1313    trace_dump_call_end();
1314 }
1315
1316 static void
1317 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1318                                   struct pipe_surface *dst,
1319                                   unsigned clear_flags,
1320                                   double depth,
1321                                   unsigned stencil,
1322                                   unsigned dstx, unsigned dsty,
1323                                   unsigned width, unsigned height)
1324 {
1325    struct trace_context *tr_ctx = trace_context(_pipe);
1326    struct pipe_context *pipe = tr_ctx->pipe;
1327
1328    dst = trace_surface_unwrap(tr_ctx, dst);
1329
1330    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1331
1332    trace_dump_arg(ptr, pipe);
1333    trace_dump_arg(ptr, dst);
1334    trace_dump_arg(uint, clear_flags);
1335    trace_dump_arg(float, depth);
1336    trace_dump_arg(uint, stencil);
1337    trace_dump_arg(uint, dstx);
1338    trace_dump_arg(uint, dsty);
1339    trace_dump_arg(uint, width);
1340    trace_dump_arg(uint, height);
1341
1342    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1343                              dstx, dsty, width, height);
1344
1345    trace_dump_call_end();
1346 }
1347
1348 static inline void
1349 trace_context_clear_texture(struct pipe_context *_pipe,
1350                             struct pipe_resource *res,
1351                             unsigned level,
1352                             const struct pipe_box *box,
1353                             const void *data)
1354 {
1355    struct trace_context *tr_ctx = trace_context(_pipe);
1356    struct pipe_context *pipe = tr_ctx->pipe;
1357
1358    res = trace_resource_unwrap(tr_ctx, res);
1359
1360    trace_dump_call_begin("pipe_context", "clear_texture");
1361
1362    trace_dump_arg(ptr, pipe);
1363    trace_dump_arg(ptr, res);
1364    trace_dump_arg(uint, level);
1365    trace_dump_arg_begin("box");
1366    trace_dump_box(box);
1367    trace_dump_arg_end();
1368    trace_dump_arg(ptr, data);
1369
1370    pipe->clear_texture(pipe, res, level, box, data);
1371
1372    trace_dump_call_end();
1373 }
1374
1375 static void
1376 trace_context_flush(struct pipe_context *_pipe,
1377                     struct pipe_fence_handle **fence,
1378                     unsigned flags)
1379 {
1380    struct trace_context *tr_ctx = trace_context(_pipe);
1381    struct pipe_context *pipe = tr_ctx->pipe;
1382
1383    trace_dump_call_begin("pipe_context", "flush");
1384
1385    trace_dump_arg(ptr, pipe);
1386    trace_dump_arg(uint, flags);
1387
1388    pipe->flush(pipe, fence, flags);
1389
1390    if (fence)
1391       trace_dump_ret(ptr, *fence);
1392
1393    trace_dump_call_end();
1394 }
1395
1396
1397 static inline boolean
1398 trace_context_generate_mipmap(struct pipe_context *_pipe,
1399                               struct pipe_resource *res,
1400                               enum pipe_format format,
1401                               unsigned base_level,
1402                               unsigned last_level,
1403                               unsigned first_layer,
1404                               unsigned last_layer)
1405 {
1406    struct trace_context *tr_ctx = trace_context(_pipe);
1407    struct pipe_context *pipe = tr_ctx->pipe;
1408    boolean ret;
1409
1410    res = trace_resource_unwrap(tr_ctx, res);
1411
1412    trace_dump_call_begin("pipe_context", "generate_mipmap");
1413
1414    trace_dump_arg(ptr, pipe);
1415    trace_dump_arg(ptr, res);
1416
1417    trace_dump_arg(format, format);
1418    trace_dump_arg(uint, base_level);
1419    trace_dump_arg(uint, last_level);
1420    trace_dump_arg(uint, first_layer);
1421    trace_dump_arg(uint, last_layer);
1422
1423    ret = pipe->generate_mipmap(pipe, res, format, base_level, last_level,
1424                                first_layer, last_layer);
1425
1426    trace_dump_ret(bool, ret);
1427    trace_dump_call_end();
1428
1429    return ret;
1430 }
1431
1432
1433 static void
1434 trace_context_destroy(struct pipe_context *_pipe)
1435 {
1436    struct trace_context *tr_ctx = trace_context(_pipe);
1437    struct pipe_context *pipe = tr_ctx->pipe;
1438
1439    trace_dump_call_begin("pipe_context", "destroy");
1440    trace_dump_arg(ptr, pipe);
1441    trace_dump_call_end();
1442
1443    pipe->destroy(pipe);
1444
1445    FREE(tr_ctx);
1446 }
1447
1448
1449 /********************************************************************
1450  * transfer
1451  */
1452
1453
1454 static void *
1455 trace_context_transfer_map(struct pipe_context *_context,
1456                            struct pipe_resource *_resource,
1457                            unsigned level,
1458                            unsigned usage,
1459                            const struct pipe_box *box,
1460                            struct pipe_transfer **transfer)
1461 {
1462    struct trace_context *tr_context = trace_context(_context);
1463    struct trace_resource *tr_res = trace_resource(_resource);
1464    struct pipe_context *context = tr_context->pipe;
1465    struct pipe_resource *texture = tr_res->resource;
1466    struct pipe_transfer *result = NULL;
1467    void *map;
1468
1469    assert(texture->screen == context->screen);
1470
1471    /*
1472     * Map and transfers can't be serialized so we convert all write transfers
1473     * to texture/buffer_subdata and ignore read transfers.
1474     */
1475
1476    map = context->transfer_map(context, texture, level, usage, box, &result);
1477    if (!map)
1478       return NULL;
1479
1480    *transfer = trace_transfer_create(tr_context, tr_res, result);
1481
1482    if (map) {
1483       if (usage & PIPE_TRANSFER_WRITE) {
1484          trace_transfer(*transfer)->map = map;
1485       }
1486    }
1487
1488    return *transfer ? map : NULL;
1489 }
1490
1491 static void
1492 trace_context_transfer_flush_region( struct pipe_context *_context,
1493                                      struct pipe_transfer *_transfer,
1494                                      const struct pipe_box *box)
1495 {
1496    struct trace_context *tr_context = trace_context(_context);
1497    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1498    struct pipe_context *context = tr_context->pipe;
1499    struct pipe_transfer *transfer = tr_transfer->transfer;
1500
1501    context->transfer_flush_region(context, transfer, box);
1502 }
1503
1504 static void
1505 trace_context_transfer_unmap(struct pipe_context *_context,
1506                              struct pipe_transfer *_transfer)
1507 {
1508    struct trace_context *tr_ctx = trace_context(_context);
1509    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1510    struct pipe_context *context = tr_ctx->pipe;
1511    struct pipe_transfer *transfer = tr_trans->transfer;
1512
1513    if (tr_trans->map) {
1514       /*
1515        * Fake a texture/buffer_subdata
1516        */
1517
1518       struct pipe_resource *resource = transfer->resource;
1519       unsigned level = transfer->level;
1520       unsigned usage = transfer->usage;
1521       const struct pipe_box *box = &transfer->box;
1522       unsigned stride = transfer->stride;
1523       unsigned layer_stride = transfer->layer_stride;
1524
1525       if (resource->target == PIPE_BUFFER)
1526          trace_dump_call_begin("pipe_context", "buffer_subdata");
1527       else
1528          trace_dump_call_begin("pipe_context", "texture_subdata");
1529
1530       trace_dump_arg(ptr, context);
1531       trace_dump_arg(ptr, resource);
1532       trace_dump_arg(uint, level);
1533       trace_dump_arg(uint, usage);
1534       trace_dump_arg(box, box);
1535
1536       trace_dump_arg_begin("data");
1537       trace_dump_box_bytes(tr_trans->map,
1538                            resource,
1539                            box,
1540                            stride,
1541                            layer_stride);
1542       trace_dump_arg_end();
1543
1544       trace_dump_arg(uint, stride);
1545       trace_dump_arg(uint, layer_stride);
1546
1547       trace_dump_call_end();
1548
1549       tr_trans->map = NULL;
1550    }
1551
1552    context->transfer_unmap(context, transfer);
1553    trace_transfer_destroy(tr_ctx, tr_trans);
1554 }
1555
1556
1557 static void
1558 trace_context_buffer_subdata(struct pipe_context *_context,
1559                              struct pipe_resource *_resource,
1560                              unsigned usage, unsigned offset,
1561                              unsigned size, const void *data)
1562 {
1563    struct trace_context *tr_context = trace_context(_context);
1564    struct trace_resource *tr_res = trace_resource(_resource);
1565    struct pipe_context *context = tr_context->pipe;
1566    struct pipe_resource *resource = tr_res->resource;
1567    struct pipe_box box;
1568
1569    assert(resource->screen == context->screen);
1570
1571    trace_dump_call_begin("pipe_context", "buffer_subdata");
1572
1573    trace_dump_arg(ptr, context);
1574    trace_dump_arg(ptr, resource);
1575    trace_dump_arg(uint, usage);
1576    trace_dump_arg(uint, offset);
1577    trace_dump_arg(uint, size);
1578
1579    trace_dump_arg_begin("data");
1580    u_box_1d(offset, size, &box);
1581    trace_dump_box_bytes(data, resource, &box, 0, 0);
1582    trace_dump_arg_end();
1583
1584    trace_dump_call_end();
1585
1586    context->buffer_subdata(context, resource, usage, offset, size, data);
1587 }
1588
1589
1590 static void
1591 trace_context_texture_subdata(struct pipe_context *_context,
1592                               struct pipe_resource *_resource,
1593                               unsigned level,
1594                               unsigned usage,
1595                               const struct pipe_box *box,
1596                               const void *data,
1597                               unsigned stride,
1598                               unsigned layer_stride)
1599 {
1600    struct trace_context *tr_context = trace_context(_context);
1601    struct trace_resource *tr_res = trace_resource(_resource);
1602    struct pipe_context *context = tr_context->pipe;
1603    struct pipe_resource *resource = tr_res->resource;
1604
1605    assert(resource->screen == context->screen);
1606
1607    trace_dump_call_begin("pipe_context", "texture_subdata");
1608
1609    trace_dump_arg(ptr, context);
1610    trace_dump_arg(ptr, resource);
1611    trace_dump_arg(uint, level);
1612    trace_dump_arg(uint, usage);
1613    trace_dump_arg(box, box);
1614
1615    trace_dump_arg_begin("data");
1616    trace_dump_box_bytes(data,
1617                         resource,
1618                         box,
1619                         stride,
1620                         layer_stride);
1621    trace_dump_arg_end();
1622
1623    trace_dump_arg(uint, stride);
1624    trace_dump_arg(uint, layer_stride);
1625
1626    trace_dump_call_end();
1627
1628    context->texture_subdata(context, resource, level, usage, box,
1629                             data, stride, layer_stride);
1630 }
1631
1632
1633 static void
1634 trace_context_render_condition(struct pipe_context *_context,
1635                                struct pipe_query *query,
1636                                boolean condition,
1637                                uint mode)
1638 {
1639    struct trace_context *tr_context = trace_context(_context);
1640    struct pipe_context *context = tr_context->pipe;
1641
1642    query = trace_query_unwrap(query);
1643
1644    trace_dump_call_begin("pipe_context", "render_condition");
1645
1646    trace_dump_arg(ptr, context);
1647    trace_dump_arg(ptr, query);
1648    trace_dump_arg(bool, condition);
1649    trace_dump_arg(uint, mode);
1650
1651    trace_dump_call_end();
1652
1653    context->render_condition(context, query, condition, mode);
1654 }
1655
1656
1657 static void
1658 trace_context_texture_barrier(struct pipe_context *_context)
1659 {
1660    struct trace_context *tr_context = trace_context(_context);
1661    struct pipe_context *context = tr_context->pipe;
1662
1663    trace_dump_call_begin("pipe_context", "texture_barrier");
1664
1665    trace_dump_arg(ptr, context);
1666
1667    trace_dump_call_end();
1668
1669    context->texture_barrier(context);
1670 }
1671
1672
1673 static void
1674 trace_context_memory_barrier(struct pipe_context *_context,
1675                              unsigned flags)
1676 {
1677    struct trace_context *tr_context = trace_context(_context);
1678    struct pipe_context *context = tr_context->pipe;
1679
1680    trace_dump_call_begin("pipe_context", "memory_barrier");
1681    trace_dump_arg(ptr, context);
1682    trace_dump_arg(uint, flags);
1683    trace_dump_call_end();
1684
1685    context->memory_barrier(context, flags);
1686 }
1687
1688
1689 static void
1690 trace_context_set_tess_state(struct pipe_context *_context,
1691                              const float default_outer_level[4],
1692                              const float default_inner_level[2])
1693 {
1694    struct trace_context *tr_context = trace_context(_context);
1695    struct pipe_context *context = tr_context->pipe;
1696
1697    trace_dump_call_begin("pipe_context", "set_tess_state");
1698    trace_dump_arg(ptr, context);
1699    trace_dump_arg_array(float, default_outer_level, 4);
1700    trace_dump_arg_array(float, default_inner_level, 2);
1701    trace_dump_call_end();
1702
1703    context->set_tess_state(context, default_outer_level, default_inner_level);
1704 }
1705
1706
1707 static void trace_context_set_shader_buffers(struct pipe_context *_context,
1708                                              unsigned shader,
1709                                              unsigned start, unsigned nr,
1710                                              const struct pipe_shader_buffer *buffers)
1711 {
1712    struct trace_context *tr_context = trace_context(_context);
1713    struct pipe_context *context = tr_context->pipe;
1714    struct pipe_shader_buffer *_buffers = NULL;
1715
1716    trace_dump_call_begin("pipe_context", "set_shader_buffers");
1717    trace_dump_arg(ptr, context);
1718    trace_dump_arg(uint, shader);
1719    trace_dump_arg(uint, start);
1720    trace_dump_arg_begin("buffers");
1721    trace_dump_struct_array(shader_buffer, buffers, nr);
1722    trace_dump_arg_end();
1723    trace_dump_call_end();
1724
1725    if (buffers) {
1726       int i;
1727
1728       _buffers = MALLOC(nr * sizeof(struct pipe_shader_buffer));
1729       if (!_buffers)
1730          return;
1731
1732       for (i = 0; i < nr; i++) {
1733          _buffers[i] = buffers[i];
1734          _buffers[i].buffer = trace_resource_unwrap(
1735             tr_context, _buffers[i].buffer);
1736       }
1737    }
1738
1739    context->set_shader_buffers(context, shader, start, nr, _buffers);
1740
1741    if (_buffers)
1742       FREE(_buffers);
1743 }
1744
1745 static void trace_context_set_shader_images(struct pipe_context *_context,
1746                                             unsigned shader,
1747                                             unsigned start, unsigned nr,
1748                                             const struct pipe_image_view *images)
1749 {
1750    struct trace_context *tr_context = trace_context(_context);
1751    struct pipe_context *context = tr_context->pipe;
1752    struct pipe_image_view *_images = NULL;
1753
1754    trace_dump_call_begin("pipe_context", "set_shader_images");
1755    trace_dump_arg(ptr, context);
1756    trace_dump_arg(uint, shader);
1757    trace_dump_arg(uint, start);
1758    trace_dump_arg_begin("images");
1759    trace_dump_struct_array(image_view, images, nr);
1760    trace_dump_arg_end();
1761    trace_dump_call_end();
1762
1763    if (images) {
1764       int i;
1765
1766       _images = MALLOC(nr * sizeof(struct pipe_image_view));
1767       if (!_images)
1768          return;
1769
1770       for (i = 0; i < nr; i++) {
1771          _images[i] = images[i];
1772          _images[i].resource = trace_resource_unwrap(tr_context,
1773                                                      _images[i].resource);
1774       }
1775    }
1776
1777    context->set_shader_images(context, shader, start, nr, _images);
1778
1779    if (_images)
1780       FREE(_images);
1781 }
1782
1783 static void trace_context_launch_grid(struct pipe_context *_pipe,
1784                                       const struct pipe_grid_info *info)
1785 {
1786    struct trace_context *tr_ctx = trace_context(_pipe);
1787    struct pipe_context *pipe = tr_ctx->pipe;
1788
1789    trace_dump_call_begin("pipe_context", "launch_grid");
1790
1791    trace_dump_arg(ptr,  pipe);
1792    trace_dump_arg(grid_info, info);
1793
1794    trace_dump_trace_flush();
1795
1796    if (info->indirect) {
1797       struct pipe_grid_info _info;
1798
1799       memcpy(&_info, info, sizeof(_info));
1800       _info.indirect = trace_resource_unwrap(tr_ctx, _info.indirect);
1801       pipe->launch_grid(pipe, &_info);
1802    } else {
1803       pipe->launch_grid(pipe, info);
1804    }
1805
1806    trace_dump_call_end();
1807 }
1808
1809 struct pipe_context *
1810 trace_context_create(struct trace_screen *tr_scr,
1811                      struct pipe_context *pipe)
1812 {
1813    struct trace_context *tr_ctx;
1814
1815    if (!pipe)
1816       goto error1;
1817
1818    if (!trace_enabled())
1819       goto error1;
1820
1821    tr_ctx = CALLOC_STRUCT(trace_context);
1822    if (!tr_ctx)
1823       goto error1;
1824
1825    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1826    tr_ctx->base.screen = &tr_scr->base;
1827
1828    tr_ctx->base.destroy = trace_context_destroy;
1829
1830 #define TR_CTX_INIT(_member) \
1831    tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1832
1833    TR_CTX_INIT(draw_vbo);
1834    TR_CTX_INIT(render_condition);
1835    TR_CTX_INIT(create_query);
1836    TR_CTX_INIT(destroy_query);
1837    TR_CTX_INIT(begin_query);
1838    TR_CTX_INIT(end_query);
1839    TR_CTX_INIT(get_query_result);
1840    TR_CTX_INIT(set_active_query_state);
1841    TR_CTX_INIT(create_blend_state);
1842    TR_CTX_INIT(bind_blend_state);
1843    TR_CTX_INIT(delete_blend_state);
1844    TR_CTX_INIT(create_sampler_state);
1845    TR_CTX_INIT(bind_sampler_states);
1846    TR_CTX_INIT(delete_sampler_state);
1847    TR_CTX_INIT(create_rasterizer_state);
1848    TR_CTX_INIT(bind_rasterizer_state);
1849    TR_CTX_INIT(delete_rasterizer_state);
1850    TR_CTX_INIT(create_depth_stencil_alpha_state);
1851    TR_CTX_INIT(bind_depth_stencil_alpha_state);
1852    TR_CTX_INIT(delete_depth_stencil_alpha_state);
1853    TR_CTX_INIT(create_fs_state);
1854    TR_CTX_INIT(bind_fs_state);
1855    TR_CTX_INIT(delete_fs_state);
1856    TR_CTX_INIT(create_vs_state);
1857    TR_CTX_INIT(bind_vs_state);
1858    TR_CTX_INIT(delete_vs_state);
1859    TR_CTX_INIT(create_gs_state);
1860    TR_CTX_INIT(bind_gs_state);
1861    TR_CTX_INIT(delete_gs_state);
1862    TR_CTX_INIT(create_tcs_state);
1863    TR_CTX_INIT(bind_tcs_state);
1864    TR_CTX_INIT(delete_tcs_state);
1865    TR_CTX_INIT(create_tes_state);
1866    TR_CTX_INIT(bind_tes_state);
1867    TR_CTX_INIT(delete_tes_state);
1868    TR_CTX_INIT(create_compute_state);
1869    TR_CTX_INIT(bind_compute_state);
1870    TR_CTX_INIT(delete_compute_state);
1871    TR_CTX_INIT(create_vertex_elements_state);
1872    TR_CTX_INIT(bind_vertex_elements_state);
1873    TR_CTX_INIT(delete_vertex_elements_state);
1874    TR_CTX_INIT(set_blend_color);
1875    TR_CTX_INIT(set_stencil_ref);
1876    TR_CTX_INIT(set_clip_state);
1877    TR_CTX_INIT(set_sample_mask);
1878    TR_CTX_INIT(set_constant_buffer);
1879    TR_CTX_INIT(set_framebuffer_state);
1880    TR_CTX_INIT(set_polygon_stipple);
1881    TR_CTX_INIT(set_scissor_states);
1882    TR_CTX_INIT(set_viewport_states);
1883    TR_CTX_INIT(set_sampler_views);
1884    TR_CTX_INIT(create_sampler_view);
1885    TR_CTX_INIT(sampler_view_destroy);
1886    TR_CTX_INIT(create_surface);
1887    TR_CTX_INIT(surface_destroy);
1888    TR_CTX_INIT(set_vertex_buffers);
1889    TR_CTX_INIT(set_index_buffer);
1890    TR_CTX_INIT(create_stream_output_target);
1891    TR_CTX_INIT(stream_output_target_destroy);
1892    TR_CTX_INIT(set_stream_output_targets);
1893    TR_CTX_INIT(resource_copy_region);
1894    TR_CTX_INIT(blit);
1895    TR_CTX_INIT(flush_resource);
1896    TR_CTX_INIT(clear);
1897    TR_CTX_INIT(clear_render_target);
1898    TR_CTX_INIT(clear_depth_stencil);
1899    TR_CTX_INIT(clear_texture);
1900    TR_CTX_INIT(flush);
1901    TR_CTX_INIT(generate_mipmap);
1902    TR_CTX_INIT(texture_barrier);
1903    TR_CTX_INIT(memory_barrier);
1904    TR_CTX_INIT(set_tess_state);
1905    TR_CTX_INIT(set_shader_buffers);
1906    TR_CTX_INIT(launch_grid);
1907    TR_CTX_INIT(set_shader_images);
1908
1909    TR_CTX_INIT(transfer_map);
1910    TR_CTX_INIT(transfer_unmap);
1911    TR_CTX_INIT(transfer_flush_region);
1912    TR_CTX_INIT(buffer_subdata);
1913    TR_CTX_INIT(texture_subdata);
1914
1915 #undef TR_CTX_INIT
1916
1917    tr_ctx->pipe = pipe;
1918
1919    return &tr_ctx->base;
1920
1921 error1:
1922    return pipe;
1923 }
1924
1925
1926 /**
1927  * Sanity checker: check that the given context really is a
1928  * trace context (and not the wrapped driver's context).
1929  */
1930 void
1931 trace_context_check(const struct pipe_context *pipe)
1932 {
1933    MAYBE_UNUSED struct trace_context *tr_ctx = (struct trace_context *) pipe;
1934    assert(tr_ctx->base.destroy == trace_context_destroy);
1935 }