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