src/gallium/drivers/trace/tr_context.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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/u_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_state.h"
  37 #include "tr_public.h"
  38 #include "tr_screen.h"
  39 #include "tr_texture.h"
  40 #include "tr_context.h"
  41
  42
  43
  44
  45
  46 static INLINE struct pipe_resource *
  47 trace_resource_unwrap(struct trace_context *tr_ctx,
  48                      struct pipe_resource *resource)
  49 {
  50    struct trace_resource *tr_res;
  51
  52    if(!resource)
  53       return NULL;
  54
  55    tr_res = trace_resource(resource);
  56
  57    assert(tr_res->resource);
  58    return tr_res->resource;
  59 }
  60
  61
  62 static INLINE struct pipe_surface *
  63 trace_surface_unwrap(struct trace_context *tr_ctx,
  64                      struct pipe_surface *surface)
  65 {
  66    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  67    struct trace_surface *tr_surf;
  68
  69    if(!surface)
  70       return NULL;
  71
  72    assert(surface->texture);
  73    if(!surface->texture)
  74       return surface;
  75
  76    tr_surf = trace_surface(surface);
  77
  78    assert(tr_surf->surface);
  79    assert(tr_surf->surface->texture->screen == tr_scr->screen);
  80    (void) tr_scr;
  81    return tr_surf->surface;
  82 }
  83
  84
  85 static INLINE void
  86 trace_context_draw_vbo(struct pipe_context *_pipe,
  87                        const struct pipe_draw_info *info)
  88 {
  89    struct trace_context *tr_ctx = trace_context(_pipe);
  90    struct pipe_context *pipe = tr_ctx->pipe;
  91
  92    trace_dump_call_begin("pipe_context", "draw_vbo");
  93
  94    trace_dump_arg(ptr,  pipe);
  95    trace_dump_arg(draw_info, info);
  96
  97    trace_dump_trace_flush();
  98
  99    pipe->draw_vbo(pipe, info);
 100
 101    trace_dump_call_end();
 102 }
 103
 104
 105 static INLINE struct pipe_query *
 106 trace_context_create_query(struct pipe_context *_pipe,
 107                            unsigned query_type)
 108 {
 109    struct trace_context *tr_ctx = trace_context(_pipe);
 110    struct pipe_context *pipe = tr_ctx->pipe;
 111    struct pipe_query *result;
 112
 113    trace_dump_call_begin("pipe_context", "create_query");
 114
 115    trace_dump_arg(ptr, pipe);
 116    trace_dump_arg(uint, query_type);
 117
 118    result = pipe->create_query(pipe, query_type);
 119
 120    trace_dump_ret(ptr, result);
 121
 122    trace_dump_call_end();
 123
 124    return result;
 125 }
 126
 127
 128 static INLINE void
 129 trace_context_destroy_query(struct pipe_context *_pipe,
 130                             struct pipe_query *query)
 131 {
 132    struct trace_context *tr_ctx = trace_context(_pipe);
 133    struct pipe_context *pipe = tr_ctx->pipe;
 134
 135    trace_dump_call_begin("pipe_context", "destroy_query");
 136
 137    trace_dump_arg(ptr, pipe);
 138    trace_dump_arg(ptr, query);
 139
 140    pipe->destroy_query(pipe, query);
 141
 142    trace_dump_call_end();
 143 }
 144
 145
 146 static INLINE void
 147 trace_context_begin_query(struct pipe_context *_pipe,
 148                           struct pipe_query *query)
 149 {
 150    struct trace_context *tr_ctx = trace_context(_pipe);
 151    struct pipe_context *pipe = tr_ctx->pipe;
 152
 153    trace_dump_call_begin("pipe_context", "begin_query");
 154
 155    trace_dump_arg(ptr, pipe);
 156    trace_dump_arg(ptr, query);
 157
 158    pipe->begin_query(pipe, query);
 159
 160    trace_dump_call_end();
 161 }
 162
 163
 164 static INLINE void
 165 trace_context_end_query(struct pipe_context *_pipe,
 166                         struct pipe_query *query)
 167 {
 168    struct trace_context *tr_ctx = trace_context(_pipe);
 169    struct pipe_context *pipe = tr_ctx->pipe;
 170
 171    trace_dump_call_begin("pipe_context", "end_query");
 172
 173    trace_dump_arg(ptr, pipe);
 174    trace_dump_arg(ptr, query);
 175
 176    pipe->end_query(pipe, query);
 177
 178    trace_dump_call_end();
 179 }
 180
 181
 182 static INLINE boolean
 183 trace_context_get_query_result(struct pipe_context *_pipe,
 184                                struct pipe_query *query,
 185                                boolean wait,
 186                                union pipe_query_result *presult)
 187 {
 188    struct trace_context *tr_ctx = trace_context(_pipe);
 189    struct pipe_context *pipe = tr_ctx->pipe;
 190    uint64_t result;
 191    boolean _result;
 192
 193    trace_dump_call_begin("pipe_context", "get_query_result");
 194
 195    trace_dump_arg(ptr, pipe);
 196
 197    _result = pipe->get_query_result(pipe, query, wait, presult);
 198    /* XXX this depends on the query type */
 199    result = *((uint64_t*)presult);
 200
 201    trace_dump_arg(uint, result);
 202    trace_dump_ret(bool, _result);
 203
 204    trace_dump_call_end();
 205
 206    return _result;
 207 }
 208
 209
 210 static INLINE void *
 211 trace_context_create_blend_state(struct pipe_context *_pipe,
 212                                  const struct pipe_blend_state *state)
 213 {
 214    struct trace_context *tr_ctx = trace_context(_pipe);
 215    struct pipe_context *pipe = tr_ctx->pipe;
 216    void * result;
 217
 218    trace_dump_call_begin("pipe_context", "create_blend_state");
 219
 220    trace_dump_arg(ptr, pipe);
 221    trace_dump_arg(blend_state, state);
 222
 223    result = pipe->create_blend_state(pipe, state);
 224
 225    trace_dump_ret(ptr, result);
 226
 227    trace_dump_call_end();
 228
 229    return result;
 230 }
 231
 232
 233 static INLINE void
 234 trace_context_bind_blend_state(struct pipe_context *_pipe,
 235                                void *state)
 236 {
 237    struct trace_context *tr_ctx = trace_context(_pipe);
 238    struct pipe_context *pipe = tr_ctx->pipe;
 239
 240    trace_dump_call_begin("pipe_context", "bind_blend_state");
 241
 242    trace_dump_arg(ptr, pipe);
 243    trace_dump_arg(ptr, state);
 244
 245    pipe->bind_blend_state(pipe, state);
 246
 247    trace_dump_call_end();
 248 }
 249
 250
 251 static INLINE void
 252 trace_context_delete_blend_state(struct pipe_context *_pipe,
 253                                  void *state)
 254 {
 255    struct trace_context *tr_ctx = trace_context(_pipe);
 256    struct pipe_context *pipe = tr_ctx->pipe;
 257
 258    trace_dump_call_begin("pipe_context", "delete_blend_state");
 259
 260    trace_dump_arg(ptr, pipe);
 261    trace_dump_arg(ptr, state);
 262
 263    pipe->delete_blend_state(pipe, state);
 264
 265    trace_dump_call_end();
 266 }
 267
 268
 269 static INLINE void *
 270 trace_context_create_sampler_state(struct pipe_context *_pipe,
 271                                    const struct pipe_sampler_state *state)
 272 {
 273    struct trace_context *tr_ctx = trace_context(_pipe);
 274    struct pipe_context *pipe = tr_ctx->pipe;
 275    void * result;
 276
 277    trace_dump_call_begin("pipe_context", "create_sampler_state");
 278
 279    trace_dump_arg(ptr, pipe);
 280    trace_dump_arg(sampler_state, state);
 281
 282    result = pipe->create_sampler_state(pipe, state);
 283
 284    trace_dump_ret(ptr, result);
 285
 286    trace_dump_call_end();
 287
 288    return result;
 289 }
 290
 291
 292 static INLINE void
 293 trace_context_bind_sampler_states(struct pipe_context *_pipe,
 294                                   unsigned shader,
 295                                   unsigned start,
 296                                   unsigned num_states,
 297                                   void **states)
 298 {
 299    struct trace_context *tr_ctx = trace_context(_pipe);
 300    struct pipe_context *pipe = tr_ctx->pipe;
 301
 302    /* remove this when we have pipe->bind_sampler_states(..., start, ...) */
 303    assert(start == 0);
 304
 305    switch (shader) {
 306    case PIPE_SHADER_VERTEX:
 307       trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
 308       break;
 309    case PIPE_SHADER_GEOMETRY:
 310       trace_dump_call_begin("pipe_context", "bind_geometry_sampler_states");
 311       break;
 312    case PIPE_SHADER_FRAGMENT:
 313       trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
 314       break;
 315    default:
 316       debug_error("Unexpected shader in trace_context_bind_sampler_states()");
 317    }
 318
 319    trace_dump_arg(ptr, pipe);
 320    trace_dump_arg(uint, num_states);
 321    trace_dump_arg_array(ptr, states, num_states);
 322
 323    switch (shader) {
 324    case PIPE_SHADER_VERTEX:
 325       pipe->bind_vertex_sampler_states(pipe, num_states, states);
 326       break;
 327    case PIPE_SHADER_GEOMETRY:
 328       pipe->bind_geometry_sampler_states(pipe, num_states, states);
 329       break;
 330    case PIPE_SHADER_FRAGMENT:
 331       pipe->bind_fragment_sampler_states(pipe, num_states, states);
 332       break;
 333    default:
 334       debug_error("Unexpected shader in trace_context_bind_sampler_states()");
 335    }
 336
 337    trace_dump_call_end();
 338 }
 339
 340
 341 static INLINE void
 342 trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
 343                                            unsigned num,
 344                                            void **states)
 345 {
 346    trace_context_bind_sampler_states(_pipe, PIPE_SHADER_FRAGMENT,
 347                                      0, num, states);
 348 }
 349
 350
 351 static INLINE void
 352 trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
 353                                          unsigned num,
 354                                          void **states)
 355 {
 356    trace_context_bind_sampler_states(_pipe, PIPE_SHADER_VERTEX,
 357                                      0, num, states);
 358 }
 359
 360
 361 static INLINE void
 362 trace_context_delete_sampler_state(struct pipe_context *_pipe,
 363                                    void *state)
 364 {
 365    struct trace_context *tr_ctx = trace_context(_pipe);
 366    struct pipe_context *pipe = tr_ctx->pipe;
 367
 368    trace_dump_call_begin("pipe_context", "delete_sampler_state");
 369
 370    trace_dump_arg(ptr, pipe);
 371    trace_dump_arg(ptr, state);
 372
 373    pipe->delete_sampler_state(pipe, state);
 374
 375    trace_dump_call_end();
 376 }
 377
 378
 379 static INLINE void *
 380 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
 381                                       const struct pipe_rasterizer_state *state)
 382 {
 383    struct trace_context *tr_ctx = trace_context(_pipe);
 384    struct pipe_context *pipe = tr_ctx->pipe;
 385    void * result;
 386
 387    trace_dump_call_begin("pipe_context", "create_rasterizer_state");
 388
 389    trace_dump_arg(ptr, pipe);
 390    trace_dump_arg(rasterizer_state, state);
 391
 392    result = pipe->create_rasterizer_state(pipe, state);
 393
 394    trace_dump_ret(ptr, result);
 395
 396    trace_dump_call_end();
 397
 398    return result;
 399 }
 400
 401
 402 static INLINE void
 403 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
 404                                     void *state)
 405 {
 406    struct trace_context *tr_ctx = trace_context(_pipe);
 407    struct pipe_context *pipe = tr_ctx->pipe;
 408
 409    trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
 410
 411    trace_dump_arg(ptr, pipe);
 412    trace_dump_arg(ptr, state);
 413
 414    pipe->bind_rasterizer_state(pipe, state);
 415
 416    trace_dump_call_end();
 417 }
 418
 419
 420 static INLINE void
 421 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
 422                                       void *state)
 423 {
 424    struct trace_context *tr_ctx = trace_context(_pipe);
 425    struct pipe_context *pipe = tr_ctx->pipe;
 426
 427    trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
 428
 429    trace_dump_arg(ptr, pipe);
 430    trace_dump_arg(ptr, state);
 431
 432    pipe->delete_rasterizer_state(pipe, state);
 433
 434    trace_dump_call_end();
 435 }
 436
 437
 438 static INLINE void *
 439 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 440                                                const struct pipe_depth_stencil_alpha_state *state)
 441 {
 442    struct trace_context *tr_ctx = trace_context(_pipe);
 443    struct pipe_context *pipe = tr_ctx->pipe;
 444    void * result;
 445
 446    trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
 447
 448    result = pipe->create_depth_stencil_alpha_state(pipe, state);
 449
 450    trace_dump_arg(ptr, pipe);
 451    trace_dump_arg(depth_stencil_alpha_state, state);
 452
 453    trace_dump_ret(ptr, result);
 454
 455    trace_dump_call_end();
 456
 457    return result;
 458 }
 459
 460
 461 static INLINE void
 462 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 463                                              void *state)
 464 {
 465    struct trace_context *tr_ctx = trace_context(_pipe);
 466    struct pipe_context *pipe = tr_ctx->pipe;
 467
 468    trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
 469
 470    trace_dump_arg(ptr, pipe);
 471    trace_dump_arg(ptr, state);
 472
 473    pipe->bind_depth_stencil_alpha_state(pipe, state);
 474
 475    trace_dump_call_end();
 476 }
 477
 478
 479 static INLINE void
 480 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 481                                                void *state)
 482 {
 483    struct trace_context *tr_ctx = trace_context(_pipe);
 484    struct pipe_context *pipe = tr_ctx->pipe;
 485
 486    trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
 487
 488    trace_dump_arg(ptr, pipe);
 489    trace_dump_arg(ptr, state);
 490
 491    pipe->delete_depth_stencil_alpha_state(pipe, state);
 492
 493    trace_dump_call_end();
 494 }
 495
 496
 497 static INLINE void *
 498 trace_context_create_fs_state(struct pipe_context *_pipe,
 499                               const struct pipe_shader_state *state)
 500 {
 501    struct trace_context *tr_ctx = trace_context(_pipe);
 502    struct pipe_context *pipe = tr_ctx->pipe;
 503    void * result;
 504
 505    trace_dump_call_begin("pipe_context", "create_fs_state");
 506
 507    trace_dump_arg(ptr, pipe);
 508    trace_dump_arg(shader_state, state);
 509
 510    result = pipe->create_fs_state(pipe, state);
 511
 512    trace_dump_ret(ptr, result);
 513
 514    trace_dump_call_end();
 515
 516    return result;
 517 }
 518
 519
 520 static INLINE void
 521 trace_context_bind_fs_state(struct pipe_context *_pipe,
 522                             void *state)
 523 {
 524    struct trace_context *tr_ctx = trace_context(_pipe);
 525    struct pipe_context *pipe = tr_ctx->pipe;
 526
 527    trace_dump_call_begin("pipe_context", "bind_fs_state");
 528
 529    trace_dump_arg(ptr, pipe);
 530    trace_dump_arg(ptr, state);
 531
 532    pipe->bind_fs_state(pipe, state);
 533
 534    trace_dump_call_end();
 535 }
 536
 537
 538 static INLINE void
 539 trace_context_delete_fs_state(struct pipe_context *_pipe,
 540                               void *state)
 541 {
 542    struct trace_context *tr_ctx = trace_context(_pipe);
 543    struct pipe_context *pipe = tr_ctx->pipe;
 544
 545    trace_dump_call_begin("pipe_context", "delete_fs_state");
 546
 547    trace_dump_arg(ptr, pipe);
 548    trace_dump_arg(ptr, state);
 549
 550    pipe->delete_fs_state(pipe, state);
 551
 552    trace_dump_call_end();
 553 }
 554
 555
 556 static INLINE void *
 557 trace_context_create_vs_state(struct pipe_context *_pipe,
 558                               const struct pipe_shader_state *state)
 559 {
 560    struct trace_context *tr_ctx = trace_context(_pipe);
 561    struct pipe_context *pipe = tr_ctx->pipe;
 562    void * result;
 563
 564    trace_dump_call_begin("pipe_context", "create_vs_state");
 565
 566    trace_dump_arg(ptr, pipe);
 567    trace_dump_arg(shader_state, state);
 568
 569    result = pipe->create_vs_state(pipe, state);
 570
 571    trace_dump_ret(ptr, result);
 572
 573    trace_dump_call_end();
 574
 575    return result;
 576 }
 577
 578
 579 static INLINE void
 580 trace_context_bind_vs_state(struct pipe_context *_pipe,
 581                             void *state)
 582 {
 583    struct trace_context *tr_ctx = trace_context(_pipe);
 584    struct pipe_context *pipe = tr_ctx->pipe;
 585
 586    trace_dump_call_begin("pipe_context", "bind_vs_state");
 587
 588    trace_dump_arg(ptr, pipe);
 589    trace_dump_arg(ptr, state);
 590
 591    pipe->bind_vs_state(pipe, state);
 592
 593    trace_dump_call_end();
 594 }
 595
 596
 597 static INLINE void
 598 trace_context_delete_vs_state(struct pipe_context *_pipe,
 599                               void *state)
 600 {
 601    struct trace_context *tr_ctx = trace_context(_pipe);
 602    struct pipe_context *pipe = tr_ctx->pipe;
 603
 604    trace_dump_call_begin("pipe_context", "delete_vs_state");
 605
 606    trace_dump_arg(ptr, pipe);
 607    trace_dump_arg(ptr, state);
 608
 609    pipe->delete_vs_state(pipe, state);
 610
 611    trace_dump_call_end();
 612 }
 613
 614
 615 static INLINE void *
 616 trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
 617                                            unsigned num_elements,
 618                                            const struct  pipe_vertex_element *elements)
 619 {
 620    struct trace_context *tr_ctx = trace_context(_pipe);
 621    struct pipe_context *pipe = tr_ctx->pipe;
 622    void * result;
 623
 624    trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
 625
 626    trace_dump_arg(ptr, pipe);
 627    trace_dump_arg(uint, num_elements);
 628
 629    trace_dump_arg_begin("elements");
 630    trace_dump_struct_array(vertex_element, elements, num_elements);
 631    trace_dump_arg_end();
 632
 633    result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
 634
 635    trace_dump_ret(ptr, result);
 636
 637    trace_dump_call_end();
 638
 639    return result;
 640 }
 641
 642
 643 static INLINE void
 644 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
 645                                          void *state)
 646 {
 647    struct trace_context *tr_ctx = trace_context(_pipe);
 648    struct pipe_context *pipe = tr_ctx->pipe;
 649
 650    trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
 651
 652    trace_dump_arg(ptr, pipe);
 653    trace_dump_arg(ptr, state);
 654
 655    pipe->bind_vertex_elements_state(pipe, state);
 656
 657    trace_dump_call_end();
 658 }
 659
 660
 661 static INLINE void
 662 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
 663                                            void *state)
 664 {
 665    struct trace_context *tr_ctx = trace_context(_pipe);
 666    struct pipe_context *pipe = tr_ctx->pipe;
 667
 668    trace_dump_call_begin("pipe_context", "delete_vertex_elements_state");
 669
 670    trace_dump_arg(ptr, pipe);
 671    trace_dump_arg(ptr, state);
 672
 673    pipe->delete_vertex_elements_state(pipe, state);
 674
 675    trace_dump_call_end();
 676 }
 677
 678
 679 static INLINE void
 680 trace_context_set_blend_color(struct pipe_context *_pipe,
 681                               const struct pipe_blend_color *state)
 682 {
 683    struct trace_context *tr_ctx = trace_context(_pipe);
 684    struct pipe_context *pipe = tr_ctx->pipe;
 685
 686    trace_dump_call_begin("pipe_context", "set_blend_color");
 687
 688    trace_dump_arg(ptr, pipe);
 689    trace_dump_arg(blend_color, state);
 690
 691    pipe->set_blend_color(pipe, state);
 692
 693    trace_dump_call_end();
 694 }
 695
 696
 697 static INLINE void
 698 trace_context_set_stencil_ref(struct pipe_context *_pipe,
 699                               const struct pipe_stencil_ref *state)
 700 {
 701    struct trace_context *tr_ctx = trace_context(_pipe);
 702    struct pipe_context *pipe = tr_ctx->pipe;
 703
 704    trace_dump_call_begin("pipe_context", "set_stencil_ref");
 705
 706    trace_dump_arg(ptr, pipe);
 707    trace_dump_arg(stencil_ref, state);
 708
 709    pipe->set_stencil_ref(pipe, state);
 710
 711    trace_dump_call_end();
 712 }
 713
 714
 715 static INLINE void
 716 trace_context_set_clip_state(struct pipe_context *_pipe,
 717                              const struct pipe_clip_state *state)
 718 {
 719    struct trace_context *tr_ctx = trace_context(_pipe);
 720    struct pipe_context *pipe = tr_ctx->pipe;
 721
 722    trace_dump_call_begin("pipe_context", "set_clip_state");
 723
 724    trace_dump_arg(ptr, pipe);
 725    trace_dump_arg(clip_state, state);
 726
 727    pipe->set_clip_state(pipe, state);
 728
 729    trace_dump_call_end();
 730 }
 731
 732 static INLINE void
 733 trace_context_set_sample_mask(struct pipe_context *_pipe,
 734                               unsigned sample_mask)
 735 {
 736    struct trace_context *tr_ctx = trace_context(_pipe);
 737    struct pipe_context *pipe = tr_ctx->pipe;
 738
 739    trace_dump_call_begin("pipe_context", "set_sample_mask");
 740
 741    trace_dump_arg(ptr, pipe);
 742    trace_dump_arg(uint, sample_mask);
 743
 744    pipe->set_sample_mask(pipe, sample_mask);
 745
 746    trace_dump_call_end();
 747 }
 748
 749 static INLINE void
 750 trace_context_set_constant_buffer(struct pipe_context *_pipe,
 751                                   uint shader, uint index,
 752                                   struct pipe_constant_buffer *constant_buffer)
 753 {
 754    struct trace_context *tr_ctx = trace_context(_pipe);
 755    struct pipe_context *pipe = tr_ctx->pipe;
 756    struct pipe_constant_buffer cb;
 757
 758    if (constant_buffer) {
 759       cb = *constant_buffer;
 760       cb.buffer = trace_resource_unwrap(tr_ctx, constant_buffer->buffer);
 761    }
 762
 763    trace_dump_call_begin("pipe_context", "set_constant_buffer");
 764
 765    trace_dump_arg(ptr, pipe);
 766    trace_dump_arg(uint, shader);
 767    trace_dump_arg(uint, index);
 768    trace_dump_arg(constant_buffer, constant_buffer);
 769
 770    pipe->set_constant_buffer(pipe, shader, index,
 771                              constant_buffer ? &cb : NULL);
 772
 773    trace_dump_call_end();
 774 }
 775
 776
 777 static INLINE void
 778 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
 779                                     const struct pipe_framebuffer_state *state)
 780 {
 781    struct trace_context *tr_ctx = trace_context(_pipe);
 782    struct pipe_context *pipe = tr_ctx->pipe;
 783    struct pipe_framebuffer_state unwrapped_state;
 784    unsigned i;
 785
 786
 787    /* Unwrap the input state */
 788    memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
 789    for(i = 0; i < state->nr_cbufs; ++i)
 790       unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
 791    for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
 792       unwrapped_state.cbufs[i] = NULL;
 793    unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
 794    state = &unwrapped_state;
 795
 796    trace_dump_call_begin("pipe_context", "set_framebuffer_state");
 797
 798    trace_dump_arg(ptr, pipe);
 799    trace_dump_arg(framebuffer_state, state);
 800
 801    pipe->set_framebuffer_state(pipe, state);
 802
 803    trace_dump_call_end();
 804 }
 805
 806
 807 static INLINE void
 808 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
 809                                   const struct pipe_poly_stipple *state)
 810 {
 811    struct trace_context *tr_ctx = trace_context(_pipe);
 812    struct pipe_context *pipe = tr_ctx->pipe;
 813
 814    trace_dump_call_begin("pipe_context", "set_polygon_stipple");
 815
 816    trace_dump_arg(ptr, pipe);
 817    trace_dump_arg(poly_stipple, state);
 818
 819    pipe->set_polygon_stipple(pipe, state);
 820
 821    trace_dump_call_end();
 822 }
 823
 824
 825 static INLINE void
 826 trace_context_set_scissor_state(struct pipe_context *_pipe,
 827                                 const struct pipe_scissor_state *state)
 828 {
 829    struct trace_context *tr_ctx = trace_context(_pipe);
 830    struct pipe_context *pipe = tr_ctx->pipe;
 831
 832    trace_dump_call_begin("pipe_context", "set_scissor_state");
 833
 834    trace_dump_arg(ptr, pipe);
 835    trace_dump_arg(scissor_state, state);
 836
 837    pipe->set_scissor_state(pipe, state);
 838
 839    trace_dump_call_end();
 840 }
 841
 842
 843 static INLINE void
 844 trace_context_set_viewport_state(struct pipe_context *_pipe,
 845                                  const struct pipe_viewport_state *state)
 846 {
 847    struct trace_context *tr_ctx = trace_context(_pipe);
 848    struct pipe_context *pipe = tr_ctx->pipe;
 849
 850    trace_dump_call_begin("pipe_context", "set_viewport_state");
 851
 852    trace_dump_arg(ptr, pipe);
 853    trace_dump_arg(viewport_state, state);
 854
 855    pipe->set_viewport_state(pipe, state);
 856
 857    trace_dump_call_end();
 858 }
 859
 860
 861 static struct pipe_sampler_view *
 862 trace_context_create_sampler_view(struct pipe_context *_pipe,
 863                           struct pipe_resource *_resource,
 864                           const struct pipe_sampler_view *templ)
 865 {
 866    struct trace_context *tr_ctx = trace_context(_pipe);
 867    struct trace_resource *tr_res = trace_resource(_resource);
 868    struct pipe_context *pipe = tr_ctx->pipe;
 869    struct pipe_resource *resource = tr_res->resource;
 870    struct pipe_sampler_view *result;
 871    struct trace_sampler_view *tr_view;
 872
 873    trace_dump_call_begin("pipe_context", "create_sampler_view");
 874
 875    trace_dump_arg(ptr, pipe);
 876    trace_dump_arg(ptr, resource);
 877
 878    trace_dump_arg_begin("templ");
 879    trace_dump_sampler_view_template(templ, resource->target);
 880    trace_dump_arg_end();
 881
 882    result = pipe->create_sampler_view(pipe, resource, templ);
 883
 884    trace_dump_ret(ptr, result);
 885
 886    trace_dump_call_end();
 887
 888    /*
 889     * Wrap pipe_sampler_view
 890     */
 891    tr_view = CALLOC_STRUCT(trace_sampler_view);
 892    tr_view->base = *templ;
 893    tr_view->base.reference.count = 1;
 894    tr_view->base.texture = NULL;
 895    pipe_resource_reference(&tr_view->base.texture, _resource);
 896    tr_view->base.context = _pipe;
 897    tr_view->sampler_view = result;
 898    result = &tr_view->base;
 899
 900    return result;
 901 }
 902
 903
 904 static void
 905 trace_context_sampler_view_destroy(struct pipe_context *_pipe,
 906                            struct pipe_sampler_view *_view)
 907 {
 908    struct trace_context *tr_ctx = trace_context(_pipe);
 909    struct trace_sampler_view *tr_view = trace_sampler_view(_view);
 910    struct pipe_context *pipe = tr_ctx->pipe;
 911    struct pipe_sampler_view *view = tr_view->sampler_view;
 912
 913    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
 914
 915    trace_dump_arg(ptr, pipe);
 916    trace_dump_arg(ptr, view);
 917
 918    pipe_sampler_view_reference(&tr_view->sampler_view, NULL);
 919
 920    trace_dump_call_end();
 921
 922    pipe_resource_reference(&_view->texture, NULL);
 923    FREE(_view);
 924 }
 925
 926 /********************************************************************
 927  * surface
 928  */
 929
 930
 931 static struct pipe_surface *
 932 trace_context_create_surface(struct pipe_context *_pipe,
 933                              struct pipe_resource *_resource,
 934                              const struct pipe_surface *surf_tmpl)
 935 {
 936    struct trace_context *tr_ctx = trace_context(_pipe);
 937    struct trace_resource *tr_res = trace_resource(_resource);
 938    struct pipe_context *pipe = tr_ctx->pipe;
 939    struct pipe_resource *resource = tr_res->resource;
 940    struct pipe_surface *result = NULL;
 941
 942    trace_dump_call_begin("pipe_context", "create_surface");
 943
 944    trace_dump_arg(ptr, pipe);
 945    trace_dump_arg(ptr, resource);
 946
 947    trace_dump_arg_begin("surf_tmpl");
 948    trace_dump_surface_template(surf_tmpl, resource->target);
 949    trace_dump_arg_end();
 950
 951
 952    result = pipe->create_surface(pipe, resource, surf_tmpl);
 953
 954    trace_dump_ret(ptr, result);
 955
 956    trace_dump_call_end();
 957
 958    result = trace_surf_create(tr_res, result);
 959
 960    return result;
 961 }
 962
 963
 964 static void
 965 trace_context_surface_destroy(struct pipe_context *_pipe,
 966                               struct pipe_surface *_surface)
 967 {
 968    struct trace_context *tr_ctx = trace_context(_pipe);
 969    struct pipe_context *pipe = tr_ctx->pipe;
 970    struct trace_surface *tr_surf = trace_surface(_surface);
 971    struct pipe_surface *surface = tr_surf->surface;
 972
 973    trace_dump_call_begin("pipe_context", "surface_destroy");
 974
 975    trace_dump_arg(ptr, pipe);
 976    trace_dump_arg(ptr, surface);
 977
 978    trace_dump_call_end();
 979
 980    trace_surf_destroy(tr_surf);
 981 }
 982
 983
 984 static INLINE void
 985 trace_context_set_sampler_views(struct pipe_context *_pipe,
 986                                 unsigned shader,
 987                                 unsigned start,
 988                                 unsigned num,
 989                                 struct pipe_sampler_view **views)
 990 {
 991    struct trace_context *tr_ctx = trace_context(_pipe);
 992    struct trace_sampler_view *tr_view;
 993    struct pipe_context *pipe = tr_ctx->pipe;
 994    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
 995    unsigned i;
 996
 997    /* remove this when we have pipe->set_sampler_views(..., start, ...) */
 998    assert(start == 0);
 999
1000    for(i = 0; i < num; ++i) {
1001       tr_view = trace_sampler_view(views[i]);
1002       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1003    }
1004    views = unwrapped_views;
1005
1006    switch (shader) {
1007    case PIPE_SHADER_VERTEX:
1008       trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
1009       break;
1010    case PIPE_SHADER_GEOMETRY:
1011       trace_dump_call_begin("pipe_context", "set_geometry_sampler_views");
1012       break;
1013    case PIPE_SHADER_FRAGMENT:
1014       trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
1015       break;
1016    default:
1017       debug_error("Unexpected shader in trace_context_set_sampler_views()");
1018    }
1019
1020    trace_dump_arg(ptr, pipe);
1021    /*trace_dump_arg(uint, shader);*/
1022    trace_dump_arg(uint, num);
1023    trace_dump_arg_array(ptr, views, num);
1024
1025    switch (shader) {
1026    case PIPE_SHADER_VERTEX:
1027       pipe->set_vertex_sampler_views(pipe, num, views);
1028       break;
1029    case PIPE_SHADER_GEOMETRY:
1030       pipe->set_geometry_sampler_views(pipe, num, views);
1031       break;
1032    case PIPE_SHADER_FRAGMENT:
1033       pipe->set_fragment_sampler_views(pipe, num, views);
1034       break;
1035    default:
1036       debug_error("Unexpected shader in trace_context_set_sampler_views()");
1037    }
1038
1039    trace_dump_call_end();
1040 }
1041
1042
1043 static INLINE void
1044 trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
1045                                          unsigned num,
1046                                          struct pipe_sampler_view **views)
1047 {
1048    trace_context_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 0, num, views);
1049 }
1050
1051
1052 static INLINE void
1053 trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
1054                                        unsigned num,
1055                                        struct pipe_sampler_view **views)
1056 {
1057    trace_context_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 0, num, views);
1058 }
1059
1060
1061 static INLINE void
1062 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1063                                  unsigned start_slot, unsigned num_buffers,
1064                                  const struct pipe_vertex_buffer *buffers)
1065 {
1066    struct trace_context *tr_ctx = trace_context(_pipe);
1067    struct pipe_context *pipe = tr_ctx->pipe;
1068    unsigned i;
1069
1070    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1071
1072    trace_dump_arg(ptr, pipe);
1073    trace_dump_arg(uint, start_slot);
1074    trace_dump_arg(uint, num_buffers);
1075
1076    trace_dump_arg_begin("buffers");
1077    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1078    trace_dump_arg_end();
1079
1080    if (buffers) {
1081       struct pipe_vertex_buffer *_buffers = MALLOC(num_buffers * sizeof(*_buffers));
1082       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1083       for (i = 0; i < num_buffers; i++)
1084          _buffers[i].buffer = trace_resource_unwrap(tr_ctx, buffers[i].buffer);
1085       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, _buffers);
1086       FREE(_buffers);
1087    } else {
1088       pipe->set_vertex_buffers(pipe, start_slot, num_buffers, NULL);
1089    }
1090
1091    trace_dump_call_end();
1092 }
1093
1094
1095 static INLINE void
1096 trace_context_set_index_buffer(struct pipe_context *_pipe,
1097                                const struct pipe_index_buffer *ib)
1098 {
1099    struct trace_context *tr_ctx = trace_context(_pipe);
1100    struct pipe_context *pipe = tr_ctx->pipe;
1101
1102    trace_dump_call_begin("pipe_context", "set_index_buffer");
1103
1104    trace_dump_arg(ptr, pipe);
1105    trace_dump_arg(index_buffer, ib);
1106
1107    if (ib) {
1108       struct pipe_index_buffer _ib;
1109       _ib = *ib;
1110       _ib.buffer = trace_resource_unwrap(tr_ctx, ib->buffer);
1111       pipe->set_index_buffer(pipe, &_ib);
1112    } else {
1113       pipe->set_index_buffer(pipe, NULL);
1114    }
1115
1116    trace_dump_call_end();
1117 }
1118
1119
1120 static INLINE struct pipe_stream_output_target *
1121 trace_context_create_stream_output_target(struct pipe_context *_pipe,
1122                                           struct pipe_resource *res,
1123                                           unsigned buffer_offset,
1124                                           unsigned buffer_size)
1125 {
1126    struct trace_context *tr_ctx = trace_context(_pipe);
1127    struct pipe_context *pipe = tr_ctx->pipe;
1128    struct pipe_stream_output_target *result;
1129
1130    res = trace_resource_unwrap(tr_ctx, res);
1131
1132    trace_dump_call_begin("pipe_context", "create_stream_output_target");
1133
1134    trace_dump_arg(ptr, pipe);
1135    trace_dump_arg(ptr, res);
1136    trace_dump_arg(uint, buffer_offset);
1137    trace_dump_arg(uint, buffer_size);
1138
1139    result = pipe->create_stream_output_target(pipe,
1140                                               res, buffer_offset, buffer_size);
1141
1142    trace_dump_call_end();
1143
1144    return result;
1145 }
1146
1147
1148 static INLINE void
1149 trace_context_stream_output_target_destroy(
1150    struct pipe_context *_pipe,
1151    struct pipe_stream_output_target *target)
1152 {
1153    struct trace_context *tr_ctx = trace_context(_pipe);
1154    struct pipe_context *pipe = tr_ctx->pipe;
1155
1156    trace_dump_call_begin("pipe_context", "stream_output_target_destroy");
1157
1158    trace_dump_arg(ptr, pipe);
1159    trace_dump_arg(ptr, target);
1160
1161    pipe->stream_output_target_destroy(pipe, target);
1162
1163    trace_dump_call_end();
1164 }
1165
1166
1167 static INLINE void
1168 trace_context_set_stream_output_targets(struct pipe_context *_pipe,
1169                                         unsigned num_targets,
1170                                         struct pipe_stream_output_target **tgs,
1171                                         unsigned append_bitmask)
1172 {
1173    struct trace_context *tr_ctx = trace_context(_pipe);
1174    struct pipe_context *pipe = tr_ctx->pipe;
1175
1176    trace_dump_call_begin("pipe_context", "set_stream_output_targets");
1177
1178    trace_dump_arg(ptr, pipe);
1179    trace_dump_arg(uint, num_targets);
1180    trace_dump_arg_array(ptr, tgs, num_targets);
1181    trace_dump_arg(uint, append_bitmask);
1182
1183    pipe->set_stream_output_targets(pipe, num_targets, tgs, append_bitmask);
1184
1185    trace_dump_call_end();
1186 }
1187
1188
1189 static INLINE void
1190 trace_context_resource_copy_region(struct pipe_context *_pipe,
1191                                    struct pipe_resource *dst,
1192                                    unsigned dst_level,
1193                                    unsigned dstx, unsigned dsty, unsigned dstz,
1194                                    struct pipe_resource *src,
1195                                    unsigned src_level,
1196                                    const struct pipe_box *src_box)
1197 {
1198    struct trace_context *tr_ctx = trace_context(_pipe);
1199    struct pipe_context *pipe = tr_ctx->pipe;
1200
1201    dst = trace_resource_unwrap(tr_ctx, dst);
1202    src = trace_resource_unwrap(tr_ctx, src);
1203
1204    trace_dump_call_begin("pipe_context", "resource_copy_region");
1205
1206    trace_dump_arg(ptr, pipe);
1207    trace_dump_arg(ptr, dst);
1208    trace_dump_arg(uint, dst_level);
1209    trace_dump_arg(uint, dstx);
1210    trace_dump_arg(uint, dsty);
1211    trace_dump_arg(uint, dstz);
1212    trace_dump_arg(ptr, src);
1213    trace_dump_arg(uint, src_level);
1214    trace_dump_arg(box, src_box);
1215
1216    pipe->resource_copy_region(pipe,
1217                               dst, dst_level, dstx, dsty, dstz,
1218                               src, src_level, src_box);
1219
1220    trace_dump_call_end();
1221 }
1222
1223
1224 static INLINE void
1225 trace_context_blit(struct pipe_context *_pipe,
1226                    const struct pipe_blit_info *_info)
1227 {
1228    struct trace_context *tr_ctx = trace_context(_pipe);
1229    struct pipe_context *pipe = tr_ctx->pipe;
1230    struct pipe_blit_info info = *_info;
1231
1232    info.dst.resource = trace_resource_unwrap(tr_ctx, info.dst.resource);
1233    info.src.resource = trace_resource_unwrap(tr_ctx, info.src.resource);
1234
1235    trace_dump_call_begin("pipe_context", "blit");
1236
1237    trace_dump_arg(ptr, pipe);
1238    trace_dump_arg(blit_info, _info);
1239
1240    pipe->blit(pipe, &info);
1241
1242    trace_dump_call_end();
1243 }
1244
1245
1246 static INLINE void
1247 trace_context_clear(struct pipe_context *_pipe,
1248                     unsigned buffers,
1249                     const union pipe_color_union *color,
1250                     double depth,
1251                     unsigned stencil)
1252 {
1253    struct trace_context *tr_ctx = trace_context(_pipe);
1254    struct pipe_context *pipe = tr_ctx->pipe;
1255
1256    trace_dump_call_begin("pipe_context", "clear");
1257
1258    trace_dump_arg(ptr, pipe);
1259    trace_dump_arg(uint, buffers);
1260    trace_dump_arg_begin("color");
1261    if (color)
1262       trace_dump_array(float, color->f, 4);
1263    else
1264       trace_dump_null();
1265    trace_dump_arg_end();
1266    trace_dump_arg(float, depth);
1267    trace_dump_arg(uint, stencil);
1268
1269    pipe->clear(pipe, buffers, color, depth, stencil);
1270
1271    trace_dump_call_end();
1272 }
1273
1274
1275 static INLINE void
1276 trace_context_clear_render_target(struct pipe_context *_pipe,
1277                                   struct pipe_surface *dst,
1278                                   const union pipe_color_union *color,
1279                                   unsigned dstx, unsigned dsty,
1280                                   unsigned width, unsigned height)
1281 {
1282    struct trace_context *tr_ctx = trace_context(_pipe);
1283    struct pipe_context *pipe = tr_ctx->pipe;
1284
1285    dst = trace_surface_unwrap(tr_ctx, dst);
1286
1287    trace_dump_call_begin("pipe_context", "clear_render_target");
1288
1289    trace_dump_arg(ptr, pipe);
1290    trace_dump_arg(ptr, dst);
1291    trace_dump_arg_array(float, color->f, 4);
1292    trace_dump_arg(uint, dstx);
1293    trace_dump_arg(uint, dsty);
1294    trace_dump_arg(uint, width);
1295    trace_dump_arg(uint, height);
1296
1297    pipe->clear_render_target(pipe, dst, color, dstx, dsty, width, height);
1298
1299    trace_dump_call_end();
1300 }
1301
1302 static INLINE void
1303 trace_context_clear_depth_stencil(struct pipe_context *_pipe,
1304                                   struct pipe_surface *dst,
1305                                   unsigned clear_flags,
1306                                   double depth,
1307                                   unsigned stencil,
1308                                   unsigned dstx, unsigned dsty,
1309                                   unsigned width, unsigned height)
1310 {
1311    struct trace_context *tr_ctx = trace_context(_pipe);
1312    struct pipe_context *pipe = tr_ctx->pipe;
1313
1314    dst = trace_surface_unwrap(tr_ctx, dst);
1315
1316    trace_dump_call_begin("pipe_context", "clear_depth_stencil");
1317
1318    trace_dump_arg(ptr, pipe);
1319    trace_dump_arg(ptr, dst);
1320    trace_dump_arg(uint, clear_flags);
1321    trace_dump_arg(float, depth);
1322    trace_dump_arg(uint, stencil);
1323    trace_dump_arg(uint, dstx);
1324    trace_dump_arg(uint, dsty);
1325    trace_dump_arg(uint, width);
1326    trace_dump_arg(uint, height);
1327
1328    pipe->clear_depth_stencil(pipe, dst, clear_flags, depth, stencil,
1329                              dstx, dsty, width, height);
1330
1331    trace_dump_call_end();
1332 }
1333
1334 static INLINE void
1335 trace_context_flush(struct pipe_context *_pipe,
1336                     struct pipe_fence_handle **fence)
1337 {
1338    struct trace_context *tr_ctx = trace_context(_pipe);
1339    struct pipe_context *pipe = tr_ctx->pipe;
1340
1341    trace_dump_call_begin("pipe_context", "flush");
1342
1343    trace_dump_arg(ptr, pipe);
1344
1345    pipe->flush(pipe, fence);
1346
1347    if(fence)
1348       trace_dump_ret(ptr, *fence);
1349
1350    trace_dump_call_end();
1351 }
1352
1353
1354 static INLINE void
1355 trace_context_destroy(struct pipe_context *_pipe)
1356 {
1357    struct trace_context *tr_ctx = trace_context(_pipe);
1358    struct pipe_context *pipe = tr_ctx->pipe;
1359
1360    trace_dump_call_begin("pipe_context", "destroy");
1361    trace_dump_arg(ptr, pipe);
1362    trace_dump_call_end();
1363
1364    pipe->destroy(pipe);
1365
1366    FREE(tr_ctx);
1367 }
1368
1369
1370 /********************************************************************
1371  * transfer
1372  */
1373
1374
1375 static void *
1376 trace_context_transfer_map(struct pipe_context *_context,
1377                            struct pipe_resource *_resource,
1378                            unsigned level,
1379                            unsigned usage,
1380                            const struct pipe_box *box,
1381                            struct pipe_transfer **transfer)
1382 {
1383    struct trace_context *tr_context = trace_context(_context);
1384    struct trace_resource *tr_res = trace_resource(_resource);
1385    struct pipe_context *context = tr_context->pipe;
1386    struct pipe_resource *texture = tr_res->resource;
1387    struct pipe_transfer *result = NULL;
1388    void *map;
1389
1390    assert(texture->screen == context->screen);
1391
1392    /*
1393     * Map and transfers can't be serialized so we convert all write transfers
1394     * to transfer_inline_write and ignore read transfers.
1395     */
1396
1397    map = context->transfer_map(context, texture, level, usage, box, &result);
1398    if (!map)
1399       return NULL;
1400
1401    *transfer = trace_transfer_create(tr_context, tr_res, result);
1402
1403    if (map) {
1404       if(usage & PIPE_TRANSFER_WRITE) {
1405          trace_transfer(*transfer)->map = map;
1406       }
1407    }
1408
1409    return *transfer ? map : NULL;
1410 }
1411
1412 static void
1413 trace_context_transfer_flush_region( struct pipe_context *_context,
1414                                      struct pipe_transfer *_transfer,
1415                                      const struct pipe_box *box)
1416 {
1417    struct trace_context *tr_context = trace_context(_context);
1418    struct trace_transfer *tr_transfer = trace_transfer(_transfer);
1419    struct pipe_context *context = tr_context->pipe;
1420    struct pipe_transfer *transfer = tr_transfer->transfer;
1421
1422    context->transfer_flush_region(context,
1423                                   transfer,
1424                                   box);
1425 }
1426
1427 static void
1428 trace_context_transfer_unmap(struct pipe_context *_context,
1429                              struct pipe_transfer *_transfer)
1430 {
1431    struct trace_context *tr_ctx = trace_context(_context);
1432    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1433    struct pipe_context *context = tr_ctx->pipe;
1434    struct pipe_transfer *transfer = tr_trans->transfer;
1435
1436    if(tr_trans->map) {
1437       /*
1438        * Fake a transfer_inline_write
1439        */
1440
1441       struct pipe_resource *resource = transfer->resource;
1442       unsigned level = transfer->level;
1443       unsigned usage = transfer->usage;
1444       const struct pipe_box *box = &transfer->box;
1445       unsigned stride = transfer->stride;
1446       unsigned layer_stride = transfer->layer_stride;
1447
1448       trace_dump_call_begin("pipe_context", "transfer_inline_write");
1449
1450       trace_dump_arg(ptr, context);
1451       trace_dump_arg(ptr, resource);
1452       trace_dump_arg(uint, level);
1453       trace_dump_arg(uint, usage);
1454       trace_dump_arg(box, box);
1455
1456       trace_dump_arg_begin("data");
1457       trace_dump_box_bytes(tr_trans->map,
1458                            resource->format,
1459                            box,
1460                            stride,
1461                            layer_stride);
1462       trace_dump_arg_end();
1463
1464       trace_dump_arg(uint, stride);
1465       trace_dump_arg(uint, layer_stride);
1466
1467       trace_dump_call_end();
1468
1469       tr_trans->map = NULL;
1470    }
1471
1472    context->transfer_unmap(context, transfer);
1473    trace_transfer_destroy(tr_ctx, tr_trans);
1474 }
1475
1476
1477 static void
1478 trace_context_transfer_inline_write(struct pipe_context *_context,
1479                                     struct pipe_resource *_resource,
1480                                     unsigned level,
1481                                     unsigned usage,
1482                                     const struct pipe_box *box,
1483                                     const void *data,
1484                                     unsigned stride,
1485                                     unsigned layer_stride)
1486 {
1487    struct trace_context *tr_context = trace_context(_context);
1488    struct trace_resource *tr_res = trace_resource(_resource);
1489    struct pipe_context *context = tr_context->pipe;
1490    struct pipe_resource *resource = tr_res->resource;
1491
1492    assert(resource->screen == context->screen);
1493
1494    trace_dump_call_begin("pipe_context", "transfer_inline_write");
1495
1496    trace_dump_arg(ptr, context);
1497    trace_dump_arg(ptr, resource);
1498    trace_dump_arg(uint, level);
1499    trace_dump_arg(uint, usage);
1500    trace_dump_arg(box, box);
1501
1502    trace_dump_arg_begin("data");
1503    trace_dump_box_bytes(data,
1504                         resource->format,
1505                         box,
1506                         stride,
1507                         layer_stride);
1508    trace_dump_arg_end();
1509
1510    trace_dump_arg(uint, stride);
1511    trace_dump_arg(uint, layer_stride);
1512
1513    trace_dump_call_end();
1514
1515    context->transfer_inline_write(context, resource,
1516                                   level, usage, box, data, stride, layer_stride);
1517 }
1518
1519
1520 static void trace_context_render_condition(struct pipe_context *_context,
1521                                            struct pipe_query *query,
1522                                            uint mode)
1523 {
1524    struct trace_context *tr_context = trace_context(_context);
1525    struct pipe_context *context = tr_context->pipe;
1526
1527    trace_dump_call_begin("pipe_context", "render_condition");
1528
1529    trace_dump_arg(ptr, context);
1530    trace_dump_arg(ptr, query);
1531    trace_dump_arg(uint, mode);
1532
1533    trace_dump_call_end();
1534
1535    context->render_condition(context, query, mode);
1536 }
1537
1538
1539 static void trace_context_texture_barrier(struct pipe_context *_context)
1540 {
1541    struct trace_context *tr_context = trace_context(_context);
1542    struct pipe_context *context = tr_context->pipe;
1543
1544    trace_dump_call_begin("pipe_context", "texture_barrier");
1545
1546    trace_dump_arg(ptr, context);
1547
1548    trace_dump_call_end();
1549
1550    context->texture_barrier(context);
1551 }
1552
1553
1554 static const struct debug_named_value rbug_blocker_flags[] = {
1555    {"before", 1, NULL},
1556    {"after", 2, NULL},
1557    DEBUG_NAMED_VALUE_END
1558 };
1559
1560 struct pipe_context *
1561 trace_context_create(struct trace_screen *tr_scr,
1562                      struct pipe_context *pipe)
1563 {
1564    struct trace_context *tr_ctx;
1565
1566    if(!pipe)
1567       goto error1;
1568
1569    if(!trace_enabled())
1570       goto error1;
1571
1572    tr_ctx = CALLOC_STRUCT(trace_context);
1573    if(!tr_ctx)
1574       goto error1;
1575
1576    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1577    tr_ctx->base.screen = &tr_scr->base;
1578
1579    tr_ctx->base.destroy = trace_context_destroy;
1580
1581 #define TR_CTX_INIT(_member) \
1582    tr_ctx->base . _member = pipe -> _member ? trace_context_ ## _member : NULL
1583
1584    TR_CTX_INIT(draw_vbo);
1585    TR_CTX_INIT(create_query);
1586    TR_CTX_INIT(destroy_query);
1587    TR_CTX_INIT(begin_query);
1588    TR_CTX_INIT(end_query);
1589    TR_CTX_INIT(get_query_result);
1590    TR_CTX_INIT(create_blend_state);
1591    TR_CTX_INIT(bind_blend_state);
1592    TR_CTX_INIT(delete_blend_state);
1593    TR_CTX_INIT(create_sampler_state);
1594    TR_CTX_INIT(bind_fragment_sampler_states);
1595    TR_CTX_INIT(bind_vertex_sampler_states);
1596    TR_CTX_INIT(delete_sampler_state);
1597    TR_CTX_INIT(create_rasterizer_state);
1598    TR_CTX_INIT(bind_rasterizer_state);
1599    TR_CTX_INIT(delete_rasterizer_state);
1600    TR_CTX_INIT(create_depth_stencil_alpha_state);
1601    TR_CTX_INIT(bind_depth_stencil_alpha_state);
1602    TR_CTX_INIT(delete_depth_stencil_alpha_state);
1603    TR_CTX_INIT(create_fs_state);
1604    TR_CTX_INIT(bind_fs_state);
1605    TR_CTX_INIT(delete_fs_state);
1606    TR_CTX_INIT(create_vs_state);
1607    TR_CTX_INIT(bind_vs_state);
1608    TR_CTX_INIT(delete_vs_state);
1609    TR_CTX_INIT(create_vertex_elements_state);
1610    TR_CTX_INIT(bind_vertex_elements_state);
1611    TR_CTX_INIT(delete_vertex_elements_state);
1612    TR_CTX_INIT(set_blend_color);
1613    TR_CTX_INIT(set_stencil_ref);
1614    TR_CTX_INIT(set_clip_state);
1615    TR_CTX_INIT(set_sample_mask);
1616    TR_CTX_INIT(set_constant_buffer);
1617    TR_CTX_INIT(set_framebuffer_state);
1618    TR_CTX_INIT(set_polygon_stipple);
1619    TR_CTX_INIT(set_scissor_state);
1620    TR_CTX_INIT(set_viewport_state);
1621    TR_CTX_INIT(set_fragment_sampler_views);
1622    TR_CTX_INIT(set_vertex_sampler_views);
1623    TR_CTX_INIT(create_sampler_view);
1624    TR_CTX_INIT(sampler_view_destroy);
1625    TR_CTX_INIT(create_surface);
1626    TR_CTX_INIT(surface_destroy);
1627    TR_CTX_INIT(set_vertex_buffers);
1628    TR_CTX_INIT(set_index_buffer);
1629    TR_CTX_INIT(create_stream_output_target);
1630    TR_CTX_INIT(stream_output_target_destroy);
1631    TR_CTX_INIT(set_stream_output_targets);
1632    TR_CTX_INIT(resource_copy_region);
1633    TR_CTX_INIT(blit);
1634    TR_CTX_INIT(clear);
1635    TR_CTX_INIT(clear_render_target);
1636    TR_CTX_INIT(clear_depth_stencil);
1637    TR_CTX_INIT(flush);
1638    TR_CTX_INIT(render_condition);
1639    TR_CTX_INIT(texture_barrier);
1640
1641    TR_CTX_INIT(transfer_map);
1642    TR_CTX_INIT(transfer_unmap);
1643    TR_CTX_INIT(transfer_flush_region);
1644    TR_CTX_INIT(transfer_inline_write);
1645
1646 #undef TR_CTX_INIT
1647
1648    tr_ctx->pipe = pipe;
1649
1650    return &tr_ctx->base;
1651
1652 error1:
1653    return pipe;
1654 }