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