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