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_memory.h"
  29 #include "pipe/p_screen.h"
  30
  31 #include "tr_dump.h"
  32 #include "tr_state.h"
  33 #include "tr_screen.h"
  34 #include "tr_texture.h"
  35 #include "tr_winsys.h"
  36 #include "tr_context.h"
  37
  38
  39 static INLINE struct pipe_texture *
  40 trace_texture_unwrap(struct trace_context *tr_ctx,
  41                      struct pipe_texture *texture)
  42 {
  43    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  44    struct trace_texture *tr_tex;
  45
  46    if(!texture)
  47       return NULL;
  48
  49    tr_tex = trace_texture(tr_scr, texture);
  50
  51    assert(tr_tex->texture);
  52    assert(tr_tex->texture->screen == tr_scr->screen);
  53    return tr_tex->texture;
  54 }
  55
  56
  57 static INLINE struct pipe_surface *
  58 trace_surface_unwrap(struct trace_context *tr_ctx,
  59                      struct pipe_surface *surface)
  60 {
  61    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  62    struct trace_texture *tr_tex;
  63    struct trace_surface *tr_surf;
  64
  65    if(!surface)
  66       return NULL;
  67
  68    assert(surface->texture);
  69    if(!surface->texture)
  70       return surface;
  71
  72    tr_tex = trace_texture(tr_scr, surface->texture);
  73    tr_surf = trace_surface(tr_tex, surface);
  74
  75    assert(tr_surf->surface);
  76    assert(tr_surf->surface->texture->screen == tr_scr->screen);
  77    return tr_surf->surface;
  78 }
  79
  80
  81 static INLINE void
  82 trace_context_set_edgeflags(struct pipe_context *_pipe,
  83                             const unsigned *bitfield)
  84 {
  85    struct trace_context *tr_ctx = trace_context(_pipe);
  86    struct pipe_context *pipe = tr_ctx->pipe;
  87
  88    trace_dump_call_begin("pipe_context", "set_edgeflags");
  89
  90    trace_dump_arg(ptr, pipe);
  91    /* FIXME: we don't know how big this array is */
  92    trace_dump_arg(ptr, bitfield);
  93
  94    pipe->set_edgeflags(pipe, bitfield);;
  95
  96    trace_dump_call_end();
  97 }
  98
  99
 100 static INLINE boolean
 101 trace_context_draw_arrays(struct pipe_context *_pipe,
 102                           unsigned mode, unsigned start, unsigned count)
 103 {
 104    struct trace_context *tr_ctx = trace_context(_pipe);
 105    struct pipe_context *pipe = tr_ctx->pipe;
 106    boolean result;
 107
 108    trace_dump_call_begin("pipe_context", "draw_arrays");
 109
 110    trace_dump_arg(ptr, pipe);
 111    trace_dump_arg(uint, mode);
 112    trace_dump_arg(uint, start);
 113    trace_dump_arg(uint, count);
 114
 115    result = pipe->draw_arrays(pipe, mode, start, count);;
 116
 117    trace_dump_ret(bool, result);
 118
 119    trace_dump_call_end();
 120
 121    return result;
 122 }
 123
 124
 125 static INLINE boolean
 126 trace_context_draw_elements(struct pipe_context *_pipe,
 127                           struct pipe_buffer *indexBuffer,
 128                           unsigned indexSize,
 129                           unsigned mode, unsigned start, unsigned count)
 130 {
 131    struct trace_context *tr_ctx = trace_context(_pipe);
 132    struct pipe_context *pipe = tr_ctx->pipe;
 133    boolean result;
 134
 135    trace_winsys_user_buffer_update(_pipe->winsys, indexBuffer);
 136
 137    trace_dump_call_begin("pipe_context", "draw_elements");
 138
 139    trace_dump_arg(ptr, pipe);
 140    trace_dump_arg(ptr, indexBuffer);
 141    trace_dump_arg(uint, indexSize);
 142    trace_dump_arg(uint, mode);
 143    trace_dump_arg(uint, start);
 144    trace_dump_arg(uint, count);
 145
 146    result = pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);;
 147
 148    trace_dump_ret(bool, result);
 149
 150    trace_dump_call_end();
 151
 152    return result;
 153 }
 154
 155
 156 static INLINE boolean
 157 trace_context_draw_range_elements(struct pipe_context *_pipe,
 158                                   struct pipe_buffer *indexBuffer,
 159                                   unsigned indexSize,
 160                                   unsigned minIndex,
 161                                   unsigned maxIndex,
 162                                   unsigned mode,
 163                                   unsigned start,
 164                                   unsigned count)
 165 {
 166    struct trace_context *tr_ctx = trace_context(_pipe);
 167    struct pipe_context *pipe = tr_ctx->pipe;
 168    boolean result;
 169
 170    trace_winsys_user_buffer_update(_pipe->winsys, indexBuffer);
 171
 172    trace_dump_call_begin("pipe_context", "draw_range_elements");
 173
 174    trace_dump_arg(ptr, pipe);
 175    trace_dump_arg(ptr, indexBuffer);
 176    trace_dump_arg(uint, indexSize);
 177    trace_dump_arg(uint, minIndex);
 178    trace_dump_arg(uint, maxIndex);
 179    trace_dump_arg(uint, mode);
 180    trace_dump_arg(uint, start);
 181    trace_dump_arg(uint, count);
 182
 183    result = pipe->draw_range_elements(pipe,
 184                                       indexBuffer,
 185                                       indexSize, minIndex, maxIndex,
 186                                       mode, start, count);
 187
 188    trace_dump_ret(bool, result);
 189
 190    trace_dump_call_end();
 191
 192    return result;
 193 }
 194
 195
 196 static INLINE struct pipe_query *
 197 trace_context_create_query(struct pipe_context *_pipe,
 198                            unsigned query_type)
 199 {
 200    struct trace_context *tr_ctx = trace_context(_pipe);
 201    struct pipe_context *pipe = tr_ctx->pipe;
 202    struct pipe_query *result;
 203
 204    trace_dump_call_begin("pipe_context", "create_query");
 205
 206    trace_dump_arg(ptr, pipe);
 207    trace_dump_arg(uint, query_type);
 208
 209    result = pipe->create_query(pipe, query_type);;
 210
 211    trace_dump_ret(ptr, result);
 212
 213    trace_dump_call_end();
 214
 215    return result;
 216 }
 217
 218
 219 static INLINE void
 220 trace_context_destroy_query(struct pipe_context *_pipe,
 221                             struct pipe_query *query)
 222 {
 223    struct trace_context *tr_ctx = trace_context(_pipe);
 224    struct pipe_context *pipe = tr_ctx->pipe;
 225
 226    trace_dump_call_begin("pipe_context", "destroy_query");
 227
 228    trace_dump_arg(ptr, pipe);
 229    trace_dump_arg(ptr, query);
 230
 231    pipe->destroy_query(pipe, query);;
 232
 233    trace_dump_call_end();
 234 }
 235
 236
 237 static INLINE void
 238 trace_context_begin_query(struct pipe_context *_pipe,
 239                           struct pipe_query *query)
 240 {
 241    struct trace_context *tr_ctx = trace_context(_pipe);
 242    struct pipe_context *pipe = tr_ctx->pipe;
 243
 244    trace_dump_call_begin("pipe_context", "begin_query");
 245
 246    trace_dump_arg(ptr, pipe);
 247    trace_dump_arg(ptr, query);
 248
 249    pipe->begin_query(pipe, query);;
 250
 251    trace_dump_call_end();
 252 }
 253
 254
 255 static INLINE void
 256 trace_context_end_query(struct pipe_context *_pipe,
 257                         struct pipe_query *query)
 258 {
 259    struct trace_context *tr_ctx = trace_context(_pipe);
 260    struct pipe_context *pipe = tr_ctx->pipe;
 261
 262    trace_dump_call_begin("pipe_context", "end_query");
 263
 264    trace_dump_arg(ptr, pipe);
 265    trace_dump_arg(ptr, query);
 266
 267    pipe->end_query(pipe, query);
 268
 269    trace_dump_call_end();
 270 }
 271
 272
 273 static INLINE boolean
 274 trace_context_get_query_result(struct pipe_context *_pipe,
 275                                struct pipe_query *query,
 276                                boolean wait,
 277                                uint64 *presult)
 278 {
 279    struct trace_context *tr_ctx = trace_context(_pipe);
 280    struct pipe_context *pipe = tr_ctx->pipe;
 281    uint64 result;
 282    boolean _result;
 283
 284    trace_dump_call_begin("pipe_context", "get_query_result");
 285
 286    trace_dump_arg(ptr, pipe);
 287
 288    _result = pipe->get_query_result(pipe, query, wait, presult);;
 289    result = *presult;
 290
 291    trace_dump_arg(uint, result);
 292    trace_dump_ret(bool, _result);
 293
 294    trace_dump_call_end();
 295
 296    return _result;
 297 }
 298
 299
 300 static INLINE void *
 301 trace_context_create_blend_state(struct pipe_context *_pipe,
 302                                  const struct pipe_blend_state *state)
 303 {
 304    struct trace_context *tr_ctx = trace_context(_pipe);
 305    struct pipe_context *pipe = tr_ctx->pipe;
 306    void * result;
 307
 308    trace_dump_call_begin("pipe_context", "create_blend_state");
 309
 310    trace_dump_arg(ptr, pipe);
 311    trace_dump_arg(blend_state, state);
 312
 313    result = pipe->create_blend_state(pipe, state);;
 314
 315    trace_dump_ret(ptr, result);
 316
 317    trace_dump_call_end();
 318
 319    return result;
 320 }
 321
 322
 323 static INLINE void
 324 trace_context_bind_blend_state(struct pipe_context *_pipe,
 325                                void *state)
 326 {
 327    struct trace_context *tr_ctx = trace_context(_pipe);
 328    struct pipe_context *pipe = tr_ctx->pipe;
 329
 330    trace_dump_call_begin("pipe_context", "bind_blend_state");
 331
 332    trace_dump_arg(ptr, pipe);
 333    trace_dump_arg(ptr, state);
 334
 335    pipe->bind_blend_state(pipe, state);;
 336
 337    trace_dump_call_end();
 338 }
 339
 340
 341 static INLINE void
 342 trace_context_delete_blend_state(struct pipe_context *_pipe,
 343                                  void *state)
 344 {
 345    struct trace_context *tr_ctx = trace_context(_pipe);
 346    struct pipe_context *pipe = tr_ctx->pipe;
 347
 348    trace_dump_call_begin("pipe_context", "delete_blend_state");
 349
 350    trace_dump_arg(ptr, pipe);
 351    trace_dump_arg(ptr, state);
 352
 353    pipe->delete_blend_state(pipe, state);;
 354
 355    trace_dump_call_end();
 356 }
 357
 358
 359 static INLINE void *
 360 trace_context_create_sampler_state(struct pipe_context *_pipe,
 361                                    const struct pipe_sampler_state *state)
 362 {
 363    struct trace_context *tr_ctx = trace_context(_pipe);
 364    struct pipe_context *pipe = tr_ctx->pipe;
 365    void * result;
 366
 367    trace_dump_call_begin("pipe_context", "create_sampler_state");
 368
 369    trace_dump_arg(ptr, pipe);
 370    trace_dump_arg(sampler_state, state);
 371
 372    result = pipe->create_sampler_state(pipe, state);;
 373
 374    trace_dump_ret(ptr, result);
 375
 376    trace_dump_call_end();
 377
 378    return result;
 379 }
 380
 381
 382 static INLINE void
 383 trace_context_bind_sampler_states(struct pipe_context *_pipe,
 384                                   unsigned num_states, void **states)
 385 {
 386    struct trace_context *tr_ctx = trace_context(_pipe);
 387    struct pipe_context *pipe = tr_ctx->pipe;
 388
 389    trace_dump_call_begin("pipe_context", "bind_sampler_states");
 390
 391    trace_dump_arg(ptr, pipe);
 392    trace_dump_arg(uint, num_states);
 393    trace_dump_arg_array(ptr, states, num_states);
 394
 395    pipe->bind_sampler_states(pipe, num_states, states);;
 396
 397    trace_dump_call_end();
 398 }
 399
 400
 401 static INLINE void
 402 trace_context_delete_sampler_state(struct pipe_context *_pipe,
 403                                    void *state)
 404 {
 405    struct trace_context *tr_ctx = trace_context(_pipe);
 406    struct pipe_context *pipe = tr_ctx->pipe;
 407
 408    trace_dump_call_begin("pipe_context", "delete_sampler_state");
 409
 410    trace_dump_arg(ptr, pipe);
 411    trace_dump_arg(ptr, state);
 412
 413    pipe->delete_sampler_state(pipe, state);;
 414
 415    trace_dump_call_end();
 416 }
 417
 418
 419 static INLINE void *
 420 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
 421                                       const struct pipe_rasterizer_state *state)
 422 {
 423    struct trace_context *tr_ctx = trace_context(_pipe);
 424    struct pipe_context *pipe = tr_ctx->pipe;
 425    void * result;
 426
 427    trace_dump_call_begin("pipe_context", "create_rasterizer_state");
 428
 429    trace_dump_arg(ptr, pipe);
 430    trace_dump_arg(rasterizer_state, state);
 431
 432    result = pipe->create_rasterizer_state(pipe, state);;
 433
 434    trace_dump_ret(ptr, result);
 435
 436    trace_dump_call_end();
 437
 438    return result;
 439 }
 440
 441
 442 static INLINE void
 443 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
 444                                     void *state)
 445 {
 446    struct trace_context *tr_ctx = trace_context(_pipe);
 447    struct pipe_context *pipe = tr_ctx->pipe;
 448
 449    trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
 450
 451    trace_dump_arg(ptr, pipe);
 452    trace_dump_arg(ptr, state);
 453
 454    pipe->bind_rasterizer_state(pipe, state);;
 455
 456    trace_dump_call_end();
 457 }
 458
 459
 460 static INLINE void
 461 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
 462                                       void *state)
 463 {
 464    struct trace_context *tr_ctx = trace_context(_pipe);
 465    struct pipe_context *pipe = tr_ctx->pipe;
 466
 467    trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
 468
 469    trace_dump_arg(ptr, pipe);
 470    trace_dump_arg(ptr, state);
 471
 472    pipe->delete_rasterizer_state(pipe, state);;
 473
 474    trace_dump_call_end();
 475 }
 476
 477
 478 static INLINE void *
 479 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 480                                                const struct pipe_depth_stencil_alpha_state *state)
 481 {
 482    struct trace_context *tr_ctx = trace_context(_pipe);
 483    struct pipe_context *pipe = tr_ctx->pipe;
 484    void * result;
 485
 486    trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
 487
 488    result = pipe->create_depth_stencil_alpha_state(pipe, state);;
 489
 490    trace_dump_arg(ptr, pipe);
 491    trace_dump_arg(depth_stencil_alpha_state, state);
 492
 493    trace_dump_ret(ptr, result);
 494
 495    trace_dump_call_end();
 496
 497    return result;
 498 }
 499
 500
 501 static INLINE void
 502 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 503                                              void *state)
 504 {
 505    struct trace_context *tr_ctx = trace_context(_pipe);
 506    struct pipe_context *pipe = tr_ctx->pipe;
 507
 508    trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
 509
 510    trace_dump_arg(ptr, pipe);
 511    trace_dump_arg(ptr, state);
 512
 513    pipe->bind_depth_stencil_alpha_state(pipe, state);;
 514
 515    trace_dump_call_end();
 516 }
 517
 518
 519 static INLINE void
 520 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 521                                                void *state)
 522 {
 523    struct trace_context *tr_ctx = trace_context(_pipe);
 524    struct pipe_context *pipe = tr_ctx->pipe;
 525
 526    trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
 527
 528    trace_dump_arg(ptr, pipe);
 529    trace_dump_arg(ptr, state);
 530
 531    pipe->delete_depth_stencil_alpha_state(pipe, state);;
 532
 533    trace_dump_call_end();
 534 }
 535
 536
 537 static INLINE void *
 538 trace_context_create_fs_state(struct pipe_context *_pipe,
 539                               const struct pipe_shader_state *state)
 540 {
 541    struct trace_context *tr_ctx = trace_context(_pipe);
 542    struct pipe_context *pipe = tr_ctx->pipe;
 543    void * result;
 544
 545    trace_dump_call_begin("pipe_context", "create_fs_state");
 546
 547    trace_dump_arg(ptr, pipe);
 548    trace_dump_arg(shader_state, state);
 549
 550    result = pipe->create_fs_state(pipe, state);;
 551
 552    trace_dump_ret(ptr, result);
 553
 554    trace_dump_call_end();
 555
 556    return result;
 557 }
 558
 559
 560 static INLINE void
 561 trace_context_bind_fs_state(struct pipe_context *_pipe,
 562                             void *state)
 563 {
 564    struct trace_context *tr_ctx = trace_context(_pipe);
 565    struct pipe_context *pipe = tr_ctx->pipe;
 566
 567    trace_dump_call_begin("pipe_context", "bind_fs_state");
 568
 569    trace_dump_arg(ptr, pipe);
 570    trace_dump_arg(ptr, state);
 571
 572    pipe->bind_fs_state(pipe, state);;
 573
 574    trace_dump_call_end();
 575 }
 576
 577
 578 static INLINE void
 579 trace_context_delete_fs_state(struct pipe_context *_pipe,
 580                               void *state)
 581 {
 582    struct trace_context *tr_ctx = trace_context(_pipe);
 583    struct pipe_context *pipe = tr_ctx->pipe;
 584
 585    trace_dump_call_begin("pipe_context", "delete_fs_state");
 586
 587    trace_dump_arg(ptr, pipe);
 588    trace_dump_arg(ptr, state);
 589
 590    pipe->delete_fs_state(pipe, state);;
 591
 592    trace_dump_call_end();
 593 }
 594
 595
 596 static INLINE void *
 597 trace_context_create_vs_state(struct pipe_context *_pipe,
 598                               const struct pipe_shader_state *state)
 599 {
 600    struct trace_context *tr_ctx = trace_context(_pipe);
 601    struct pipe_context *pipe = tr_ctx->pipe;
 602    void * result;
 603
 604    trace_dump_call_begin("pipe_context", "create_vs_state");
 605
 606    trace_dump_arg(ptr, pipe);
 607    trace_dump_arg(shader_state, state);
 608
 609    result = pipe->create_vs_state(pipe, state);;
 610
 611    trace_dump_ret(ptr, result);
 612
 613    trace_dump_call_end();
 614
 615    return result;
 616 }
 617
 618
 619 static INLINE void
 620 trace_context_bind_vs_state(struct pipe_context *_pipe,
 621                             void *state)
 622 {
 623    struct trace_context *tr_ctx = trace_context(_pipe);
 624    struct pipe_context *pipe = tr_ctx->pipe;
 625
 626    trace_dump_call_begin("pipe_context", "bind_vs_state");
 627
 628    trace_dump_arg(ptr, pipe);
 629    trace_dump_arg(ptr, state);
 630
 631    pipe->bind_vs_state(pipe, state);;
 632
 633    trace_dump_call_end();
 634 }
 635
 636
 637 static INLINE void
 638 trace_context_delete_vs_state(struct pipe_context *_pipe,
 639                               void *state)
 640 {
 641    struct trace_context *tr_ctx = trace_context(_pipe);
 642    struct pipe_context *pipe = tr_ctx->pipe;
 643
 644    trace_dump_call_begin("pipe_context", "delete_vs_state");
 645
 646    trace_dump_arg(ptr, pipe);
 647    trace_dump_arg(ptr, state);
 648
 649    pipe->delete_vs_state(pipe, state);;
 650
 651    trace_dump_call_end();
 652 }
 653
 654
 655 static INLINE void
 656 trace_context_set_blend_color(struct pipe_context *_pipe,
 657                               const struct pipe_blend_color *state)
 658 {
 659    struct trace_context *tr_ctx = trace_context(_pipe);
 660    struct pipe_context *pipe = tr_ctx->pipe;
 661
 662    trace_dump_call_begin("pipe_context", "set_blend_color");
 663
 664    trace_dump_arg(ptr, pipe);
 665    trace_dump_arg(blend_color, state);
 666
 667    pipe->set_blend_color(pipe, state);;
 668
 669    trace_dump_call_end();
 670 }
 671
 672
 673 static INLINE void
 674 trace_context_set_clip_state(struct pipe_context *_pipe,
 675                              const struct pipe_clip_state *state)
 676 {
 677    struct trace_context *tr_ctx = trace_context(_pipe);
 678    struct pipe_context *pipe = tr_ctx->pipe;
 679
 680    trace_dump_call_begin("pipe_context", "set_clip_state");
 681
 682    trace_dump_arg(ptr, pipe);
 683    trace_dump_arg(clip_state, state);
 684
 685    pipe->set_clip_state(pipe, state);;
 686
 687    trace_dump_call_end();
 688 }
 689
 690
 691 static INLINE void
 692 trace_context_set_constant_buffer(struct pipe_context *_pipe,
 693                                   uint shader, uint index,
 694                                   const struct pipe_constant_buffer *buffer)
 695 {
 696    struct trace_context *tr_ctx = trace_context(_pipe);
 697    struct pipe_context *pipe = tr_ctx->pipe;
 698
 699    trace_winsys_user_buffer_update(_pipe->winsys, (struct pipe_buffer *)buffer);
 700
 701    trace_dump_call_begin("pipe_context", "set_constant_buffer");
 702
 703    trace_dump_arg(ptr, pipe);
 704    trace_dump_arg(uint, shader);
 705    trace_dump_arg(uint, index);
 706    trace_dump_arg(constant_buffer, buffer);
 707
 708    pipe->set_constant_buffer(pipe, shader, index, buffer);;
 709
 710    trace_dump_call_end();
 711 }
 712
 713
 714 static INLINE void
 715 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
 716                                     const struct pipe_framebuffer_state *state)
 717 {
 718    struct trace_context *tr_ctx = trace_context(_pipe);
 719    struct pipe_context *pipe = tr_ctx->pipe;
 720    struct pipe_framebuffer_state unwrapped_state;
 721    unsigned i;
 722
 723    /* Unwrap the input state */
 724    memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
 725    for(i = 0; i < state->num_cbufs; ++i)
 726       unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
 727    for(i = state->num_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
 728       unwrapped_state.cbufs[i] = NULL;
 729    unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
 730    state = &unwrapped_state;
 731
 732    trace_dump_call_begin("pipe_context", "set_framebuffer_state");
 733
 734    trace_dump_arg(ptr, pipe);
 735    trace_dump_arg(framebuffer_state, state);
 736
 737    pipe->set_framebuffer_state(pipe, state);;
 738
 739    trace_dump_call_end();
 740 }
 741
 742
 743 static INLINE void
 744 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
 745                                   const struct pipe_poly_stipple *state)
 746 {
 747    struct trace_context *tr_ctx = trace_context(_pipe);
 748    struct pipe_context *pipe = tr_ctx->pipe;
 749
 750    trace_dump_call_begin("pipe_context", "set_polygon_stipple");
 751
 752    trace_dump_arg(ptr, pipe);
 753    trace_dump_arg(poly_stipple, state);
 754
 755    pipe->set_polygon_stipple(pipe, state);;
 756
 757    trace_dump_call_end();
 758 }
 759
 760
 761 static INLINE void
 762 trace_context_set_scissor_state(struct pipe_context *_pipe,
 763                                 const struct pipe_scissor_state *state)
 764 {
 765    struct trace_context *tr_ctx = trace_context(_pipe);
 766    struct pipe_context *pipe = tr_ctx->pipe;
 767
 768    trace_dump_call_begin("pipe_context", "set_scissor_state");
 769
 770    trace_dump_arg(ptr, pipe);
 771    trace_dump_arg(scissor_state, state);
 772
 773    pipe->set_scissor_state(pipe, state);;
 774
 775    trace_dump_call_end();
 776 }
 777
 778
 779 static INLINE void
 780 trace_context_set_viewport_state(struct pipe_context *_pipe,
 781                                  const struct pipe_viewport_state *state)
 782 {
 783    struct trace_context *tr_ctx = trace_context(_pipe);
 784    struct pipe_context *pipe = tr_ctx->pipe;
 785
 786    trace_dump_call_begin("pipe_context", "set_viewport_state");
 787
 788    trace_dump_arg(ptr, pipe);
 789    trace_dump_arg(viewport_state, state);
 790
 791    pipe->set_viewport_state(pipe, state);;
 792
 793    trace_dump_call_end();
 794 }
 795
 796
 797 static INLINE void
 798 trace_context_set_sampler_textures(struct pipe_context *_pipe,
 799                                    unsigned num_textures,
 800                                    struct pipe_texture **textures)
 801 {
 802    struct trace_context *tr_ctx = trace_context(_pipe);
 803    struct pipe_context *pipe = tr_ctx->pipe;
 804    struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
 805    unsigned i;
 806
 807    for(i = 0; i < num_textures; ++i)
 808       unwrapped_textures[i] = trace_texture_unwrap(tr_ctx, textures[i]);
 809    textures = unwrapped_textures;
 810
 811    trace_dump_call_begin("pipe_context", "set_sampler_textures");
 812
 813    trace_dump_arg(ptr, pipe);
 814    trace_dump_arg(uint, num_textures);
 815    trace_dump_arg_array(ptr, textures, num_textures);
 816
 817    pipe->set_sampler_textures(pipe, num_textures, textures);;
 818
 819    trace_dump_call_end();
 820 }
 821
 822
 823 static INLINE void
 824 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
 825                                  unsigned num_buffers,
 826                                  const struct pipe_vertex_buffer *buffers)
 827 {
 828    struct trace_context *tr_ctx = trace_context(_pipe);
 829    struct pipe_context *pipe = tr_ctx->pipe;
 830    unsigned i;
 831
 832    for(i = 0; i < num_buffers; ++i)
 833       trace_winsys_user_buffer_update(_pipe->winsys, buffers[i].buffer);
 834
 835    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
 836
 837    trace_dump_arg(ptr, pipe);
 838    trace_dump_arg(uint, num_buffers);
 839
 840    trace_dump_arg_begin("buffers");
 841    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
 842    trace_dump_arg_end();
 843
 844    pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
 845
 846    trace_dump_call_end();
 847 }
 848
 849
 850 static INLINE void
 851 trace_context_set_vertex_elements(struct pipe_context *_pipe,
 852                                   unsigned num_elements,
 853                                   const struct pipe_vertex_element *elements)
 854 {
 855    struct trace_context *tr_ctx = trace_context(_pipe);
 856    struct pipe_context *pipe = tr_ctx->pipe;
 857
 858    trace_dump_call_begin("pipe_context", "set_vertex_elements");
 859
 860    trace_dump_arg(ptr, pipe);
 861    trace_dump_arg(uint, num_elements);
 862
 863    trace_dump_arg_begin("elements");
 864    trace_dump_struct_array(vertex_element, elements, num_elements);
 865    trace_dump_arg_end();
 866
 867    pipe->set_vertex_elements(pipe, num_elements, elements);;
 868
 869    trace_dump_call_end();
 870 }
 871
 872
 873 static INLINE void
 874 trace_context_surface_copy(struct pipe_context *_pipe,
 875                            boolean do_flip,
 876                            struct pipe_surface *dest,
 877                            unsigned destx, unsigned desty,
 878                            struct pipe_surface *src,
 879                            unsigned srcx, unsigned srcy,
 880                            unsigned width, unsigned height)
 881 {
 882    struct trace_context *tr_ctx = trace_context(_pipe);
 883    struct pipe_context *pipe = tr_ctx->pipe;
 884
 885    dest = trace_surface_unwrap(tr_ctx, dest);
 886    src = trace_surface_unwrap(tr_ctx, src);
 887
 888    trace_dump_call_begin("pipe_context", "surface_copy");
 889
 890    trace_dump_arg(ptr, pipe);
 891    trace_dump_arg(bool, do_flip);
 892    trace_dump_arg(ptr, dest);
 893    trace_dump_arg(uint, destx);
 894    trace_dump_arg(uint, desty);
 895    trace_dump_arg(ptr, src);
 896    trace_dump_arg(uint, srcx);
 897    trace_dump_arg(uint, srcy);
 898    trace_dump_arg(uint, width);
 899    trace_dump_arg(uint, height);
 900
 901    pipe->surface_copy(pipe, do_flip,
 902                       dest, destx, desty,
 903                       src, srcx, srcy, width, height);
 904
 905    trace_dump_call_end();
 906 }
 907
 908
 909 static INLINE void
 910 trace_context_surface_fill(struct pipe_context *_pipe,
 911                            struct pipe_surface *dst,
 912                            unsigned dstx, unsigned dsty,
 913                            unsigned width, unsigned height,
 914                            unsigned value)
 915 {
 916    struct trace_context *tr_ctx = trace_context(_pipe);
 917    struct pipe_context *pipe = tr_ctx->pipe;
 918
 919    dst = trace_surface_unwrap(tr_ctx, dst);
 920
 921    trace_dump_call_begin("pipe_context", "surface_fill");
 922
 923    trace_dump_arg(ptr, pipe);
 924    trace_dump_arg(ptr, dst);
 925    trace_dump_arg(uint, dstx);
 926    trace_dump_arg(uint, dsty);
 927    trace_dump_arg(uint, width);
 928    trace_dump_arg(uint, height);
 929
 930    pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);;
 931
 932    trace_dump_call_end();
 933 }
 934
 935
 936 static INLINE void
 937 trace_context_clear(struct pipe_context *_pipe,
 938                     struct pipe_surface *surface,
 939                     unsigned clearValue)
 940 {
 941    struct trace_context *tr_ctx = trace_context(_pipe);
 942    struct pipe_context *pipe = tr_ctx->pipe;
 943
 944    surface = trace_surface_unwrap(tr_ctx, surface);
 945
 946    trace_dump_call_begin("pipe_context", "clear");
 947
 948    trace_dump_arg(ptr, pipe);
 949    trace_dump_arg(ptr, surface);
 950    trace_dump_arg(uint, clearValue);
 951
 952    pipe->clear(pipe, surface, clearValue);;
 953
 954    trace_dump_call_end();
 955 }
 956
 957
 958 static INLINE void
 959 trace_context_flush(struct pipe_context *_pipe,
 960                     unsigned flags,
 961                     struct pipe_fence_handle **fence)
 962 {
 963    struct trace_context *tr_ctx = trace_context(_pipe);
 964    struct pipe_context *pipe = tr_ctx->pipe;
 965
 966    trace_dump_call_begin("pipe_context", "flush");
 967
 968    trace_dump_arg(ptr, pipe);
 969    trace_dump_arg(uint, flags);
 970
 971    pipe->flush(pipe, flags, fence);;
 972
 973    if(fence)
 974       trace_dump_ret(ptr, *fence);
 975
 976    trace_dump_call_end();
 977 }
 978
 979
 980 static INLINE void
 981 trace_context_destroy(struct pipe_context *_pipe)
 982 {
 983    struct trace_context *tr_ctx = trace_context(_pipe);
 984    struct pipe_context *pipe = tr_ctx->pipe;
 985
 986    trace_dump_call_begin("pipe_context", "destroy");
 987
 988    trace_dump_arg(ptr, pipe);
 989
 990    pipe->destroy(pipe);
 991
 992    trace_dump_call_end();
 993
 994    FREE(tr_ctx);
 995 }
 996
 997
 998 struct pipe_context *
 999 trace_context_create(struct pipe_screen *screen,
1000                      struct pipe_context *pipe)
1001 {
1002    struct trace_context *tr_ctx;
1003
1004    if(!pipe)
1005       goto error1;
1006
1007    if(!trace_dump_enabled())
1008       goto error1;
1009
1010    tr_ctx = CALLOC_STRUCT(trace_context);
1011    if(!tr_ctx)
1012       goto error1;
1013
1014    tr_ctx->base.winsys = screen->winsys;
1015    tr_ctx->base.screen = screen;
1016    tr_ctx->base.destroy = trace_context_destroy;
1017    tr_ctx->base.set_edgeflags = trace_context_set_edgeflags;
1018    tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1019    tr_ctx->base.draw_elements = trace_context_draw_elements;
1020    tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1021    tr_ctx->base.create_query = trace_context_create_query;
1022    tr_ctx->base.destroy_query = trace_context_destroy_query;
1023    tr_ctx->base.begin_query = trace_context_begin_query;
1024    tr_ctx->base.end_query = trace_context_end_query;
1025    tr_ctx->base.get_query_result = trace_context_get_query_result;
1026    tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1027    tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1028    tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1029    tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1030    tr_ctx->base.bind_sampler_states = trace_context_bind_sampler_states;
1031    tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1032    tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1033    tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1034    tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1035    tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1036    tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1037    tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1038    tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1039    tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1040    tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1041    tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1042    tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1043    tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1044    tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1045    tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1046    tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1047    tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1048    tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1049    tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1050    tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1051    tr_ctx->base.set_sampler_textures = trace_context_set_sampler_textures;
1052    tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1053    tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
1054    tr_ctx->base.surface_copy = trace_context_surface_copy;
1055    tr_ctx->base.surface_fill = trace_context_surface_fill;
1056    tr_ctx->base.clear = trace_context_clear;
1057    tr_ctx->base.flush = trace_context_flush;
1058
1059    tr_ctx->pipe = pipe;
1060
1061    trace_dump_call_begin("", "pipe_context_create");
1062    trace_dump_arg_begin("screen");
1063    trace_dump_ptr(pipe->screen);
1064    trace_dump_arg_end();
1065    trace_dump_ret(ptr, pipe);
1066    trace_dump_call_end();
1067
1068    return &tr_ctx->base;
1069
1070 error1:
1071    return pipe;
1072 }