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_call_end(stream);
 279
 280    return result;
 281 }
 282
 283
 284 static INLINE void
 285 trace_context_bind_blend_state(struct pipe_context *_pipe,
 286                                void *state)
 287 {
 288    struct trace_context *tr_ctx = trace_context(_pipe);
 289    struct trace_stream *stream = tr_ctx->stream;
 290    struct pipe_context *pipe = tr_ctx->pipe;
 291
 292    trace_dump_call_begin(stream, "pipe_context", "bind_blend_state");
 293
 294    trace_dump_arg(stream, ptr, pipe);
 295    trace_dump_arg(stream, ptr, state);
 296
 297    pipe->bind_blend_state(pipe, state);;
 298
 299    trace_dump_call_end(stream);
 300 }
 301
 302
 303 static INLINE void
 304 trace_context_delete_blend_state(struct pipe_context *_pipe,
 305                                  void *state)
 306 {
 307    struct trace_context *tr_ctx = trace_context(_pipe);
 308    struct trace_stream *stream = tr_ctx->stream;
 309    struct pipe_context *pipe = tr_ctx->pipe;
 310
 311    trace_dump_call_begin(stream, "pipe_context", "delete_blend_state");
 312
 313    trace_dump_arg(stream, ptr, pipe);
 314    trace_dump_arg(stream, ptr, state);
 315
 316    pipe->delete_blend_state(pipe, state);;
 317
 318    trace_dump_call_end(stream);
 319 }
 320
 321
 322 static INLINE void *
 323 trace_context_create_sampler_state(struct pipe_context *_pipe,
 324                                    const struct pipe_sampler_state *state)
 325 {
 326    struct trace_context *tr_ctx = trace_context(_pipe);
 327    struct trace_stream *stream = tr_ctx->stream;
 328    struct pipe_context *pipe = tr_ctx->pipe;
 329    void * result;
 330
 331    trace_dump_call_begin(stream, "pipe_context", "create_sampler_state");
 332
 333    trace_dump_arg(stream, ptr, pipe);
 334    trace_dump_arg(stream, ptr, state);
 335
 336    result = pipe->create_sampler_state(pipe, state);;
 337
 338    trace_dump_ret(stream, sampler_state, result);
 339
 340    trace_dump_call_end(stream);
 341
 342    return result;
 343 }
 344
 345
 346 static INLINE void
 347 trace_context_bind_sampler_states(struct pipe_context *_pipe,
 348                                   unsigned num_states, void **states)
 349 {
 350    struct trace_context *tr_ctx = trace_context(_pipe);
 351    struct trace_stream *stream = tr_ctx->stream;
 352    struct pipe_context *pipe = tr_ctx->pipe;
 353
 354    trace_dump_call_begin(stream, "pipe_context", "bind_sampler_states");
 355
 356    trace_dump_arg(stream, ptr, pipe);
 357    trace_dump_arg(stream, uint, num_states);
 358    trace_dump_arg_array(stream, ptr, states, num_states);
 359
 360    pipe->bind_sampler_states(pipe, num_states, states);;
 361
 362    trace_dump_call_end(stream);
 363 }
 364
 365
 366 static INLINE void
 367 trace_context_delete_sampler_state(struct pipe_context *_pipe,
 368                                    void *state)
 369 {
 370    struct trace_context *tr_ctx = trace_context(_pipe);
 371    struct trace_stream *stream = tr_ctx->stream;
 372    struct pipe_context *pipe = tr_ctx->pipe;
 373
 374    trace_dump_call_begin(stream, "pipe_context", "delete_sampler_state");
 375
 376    trace_dump_arg(stream, ptr, pipe);
 377    trace_dump_arg(stream, ptr, state);
 378
 379    pipe->delete_sampler_state(pipe, state);;
 380
 381    trace_dump_call_end(stream);
 382 }
 383
 384
 385 static INLINE void *
 386 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
 387                                       const struct pipe_rasterizer_state *state)
 388 {
 389    struct trace_context *tr_ctx = trace_context(_pipe);
 390    struct trace_stream *stream = tr_ctx->stream;
 391    struct pipe_context *pipe = tr_ctx->pipe;
 392    void * result;
 393
 394    trace_dump_call_begin(stream, "pipe_context", "create_rasterizer_state");
 395
 396    trace_dump_arg(stream, ptr, pipe);
 397    trace_dump_arg(stream, rasterizer_state, state);
 398
 399    result = pipe->create_rasterizer_state(pipe, state);;
 400
 401    trace_dump_ret(stream, ptr, result);
 402
 403    trace_dump_call_end(stream);
 404
 405    return result;
 406 }
 407
 408
 409 static INLINE void
 410 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
 411                                     void *state)
 412 {
 413    struct trace_context *tr_ctx = trace_context(_pipe);
 414    struct trace_stream *stream = tr_ctx->stream;
 415    struct pipe_context *pipe = tr_ctx->pipe;
 416
 417    trace_dump_call_begin(stream, "pipe_context", "bind_rasterizer_state");
 418
 419    trace_dump_arg(stream, ptr, pipe);
 420    trace_dump_arg(stream, ptr, state);
 421
 422    pipe->bind_rasterizer_state(pipe, state);;
 423
 424    trace_dump_call_end(stream);
 425 }
 426
 427
 428 static INLINE void
 429 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
 430                                       void *state)
 431 {
 432    struct trace_context *tr_ctx = trace_context(_pipe);
 433    struct trace_stream *stream = tr_ctx->stream;
 434    struct pipe_context *pipe = tr_ctx->pipe;
 435
 436    trace_dump_call_begin(stream, "pipe_context", "delete_rasterizer_state");
 437
 438    trace_dump_arg(stream, ptr, pipe);
 439    trace_dump_arg(stream, ptr, state);
 440
 441    pipe->delete_rasterizer_state(pipe, state);;
 442
 443    trace_dump_call_end(stream);
 444 }
 445
 446
 447 static INLINE void *
 448 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 449                                                const struct pipe_depth_stencil_alpha_state *state)
 450 {
 451    struct trace_context *tr_ctx = trace_context(_pipe);
 452    struct trace_stream *stream = tr_ctx->stream;
 453    struct pipe_context *pipe = tr_ctx->pipe;
 454    void * result;
 455
 456    trace_dump_call_begin(stream, "pipe_context", "create_depth_stencil_alpha_state");
 457
 458    result = pipe->create_depth_stencil_alpha_state(pipe, state);;
 459
 460    trace_dump_ret(stream, ptr, result);
 461    trace_dump_arg(stream, depth_stencil_alpha_state, state);
 462
 463    trace_dump_call_end(stream);
 464
 465    return result;
 466 }
 467
 468
 469 static INLINE void
 470 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 471                                              void *state)
 472 {
 473    struct trace_context *tr_ctx = trace_context(_pipe);
 474    struct trace_stream *stream = tr_ctx->stream;
 475    struct pipe_context *pipe = tr_ctx->pipe;
 476
 477    trace_dump_call_begin(stream, "pipe_context", "bind_depth_stencil_alpha_state");
 478
 479    trace_dump_arg(stream, ptr, pipe);
 480    trace_dump_arg(stream, ptr, state);
 481
 482    pipe->bind_depth_stencil_alpha_state(pipe, state);;
 483
 484    trace_dump_call_end(stream);
 485 }
 486
 487
 488 static INLINE void
 489 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 490                                                void *state)
 491 {
 492    struct trace_context *tr_ctx = trace_context(_pipe);
 493    struct trace_stream *stream = tr_ctx->stream;
 494    struct pipe_context *pipe = tr_ctx->pipe;
 495
 496    trace_dump_call_begin(stream, "pipe_context", "delete_depth_stencil_alpha_state");
 497
 498    trace_dump_arg(stream, ptr, pipe);
 499    trace_dump_arg(stream, ptr, state);
 500
 501    pipe->delete_depth_stencil_alpha_state(pipe, state);;
 502
 503    trace_dump_call_end(stream);
 504 }
 505
 506
 507 static INLINE void *
 508 trace_context_create_fs_state(struct pipe_context *_pipe,
 509                               const struct pipe_shader_state *state)
 510 {
 511    struct trace_context *tr_ctx = trace_context(_pipe);
 512    struct trace_stream *stream = tr_ctx->stream;
 513    struct pipe_context *pipe = tr_ctx->pipe;
 514    void * result;
 515
 516    trace_dump_call_begin(stream, "pipe_context", "create_fs_state");
 517
 518    trace_dump_arg(stream, ptr, pipe);
 519    trace_dump_arg(stream, shader_state, state);
 520
 521    result = pipe->create_fs_state(pipe, state);;
 522
 523    trace_dump_ret(stream, ptr, result);
 524
 525    trace_dump_call_end(stream);
 526
 527    return result;
 528 }
 529
 530
 531 static INLINE void
 532 trace_context_bind_fs_state(struct pipe_context *_pipe,
 533                             void *state)
 534 {
 535    struct trace_context *tr_ctx = trace_context(_pipe);
 536    struct trace_stream *stream = tr_ctx->stream;
 537    struct pipe_context *pipe = tr_ctx->pipe;
 538
 539    trace_dump_call_begin(stream, "pipe_context", "bind_fs_state");
 540
 541    trace_dump_arg(stream, ptr, pipe);
 542    trace_dump_arg(stream, ptr, state);
 543
 544    pipe->bind_fs_state(pipe, state);;
 545
 546    trace_dump_call_end(stream);
 547 }
 548
 549
 550 static INLINE void
 551 trace_context_delete_fs_state(struct pipe_context *_pipe,
 552                               void *state)
 553 {
 554    struct trace_context *tr_ctx = trace_context(_pipe);
 555    struct trace_stream *stream = tr_ctx->stream;
 556    struct pipe_context *pipe = tr_ctx->pipe;
 557
 558    trace_dump_call_begin(stream, "pipe_context", "delete_fs_state");
 559
 560    trace_dump_arg(stream, ptr, pipe);
 561    trace_dump_arg(stream, ptr, state);
 562
 563    pipe->delete_fs_state(pipe, state);;
 564
 565    trace_dump_call_end(stream);
 566 }
 567
 568
 569 static INLINE void *
 570 trace_context_create_vs_state(struct pipe_context *_pipe,
 571                               const struct pipe_shader_state *state)
 572 {
 573    struct trace_context *tr_ctx = trace_context(_pipe);
 574    struct trace_stream *stream = tr_ctx->stream;
 575    struct pipe_context *pipe = tr_ctx->pipe;
 576    void * result;
 577
 578    trace_dump_call_begin(stream, "pipe_context", "create_vs_state");
 579
 580    trace_dump_arg(stream, ptr, pipe);
 581    trace_dump_arg(stream, shader_state, state);
 582
 583    result = pipe->create_vs_state(pipe, state);;
 584
 585    trace_dump_ret(stream, ptr, result);
 586
 587    trace_dump_call_end(stream);
 588
 589    return result;
 590 }
 591
 592
 593 static INLINE void
 594 trace_context_bind_vs_state(struct pipe_context *_pipe,
 595                             void *state)
 596 {
 597    struct trace_context *tr_ctx = trace_context(_pipe);
 598    struct trace_stream *stream = tr_ctx->stream;
 599    struct pipe_context *pipe = tr_ctx->pipe;
 600
 601    trace_dump_call_begin(stream, "pipe_context", "bind_vs_state");
 602
 603    trace_dump_arg(stream, ptr, pipe);
 604    trace_dump_arg(stream, ptr, state);
 605
 606    pipe->bind_vs_state(pipe, state);;
 607
 608    trace_dump_call_end(stream);
 609 }
 610
 611
 612 static INLINE void
 613 trace_context_delete_vs_state(struct pipe_context *_pipe,
 614                               void *state)
 615 {
 616    struct trace_context *tr_ctx = trace_context(_pipe);
 617    struct trace_stream *stream = tr_ctx->stream;
 618    struct pipe_context *pipe = tr_ctx->pipe;
 619
 620    trace_dump_call_begin(stream, "pipe_context", "delete_vs_state");
 621
 622    trace_dump_arg(stream, ptr, pipe);
 623    trace_dump_arg(stream, ptr, state);
 624
 625    pipe->delete_vs_state(pipe, state);;
 626
 627    trace_dump_call_end(stream);
 628 }
 629
 630
 631 static INLINE void
 632 trace_context_set_blend_color(struct pipe_context *_pipe,
 633                               const struct pipe_blend_color *state)
 634 {
 635    struct trace_context *tr_ctx = trace_context(_pipe);
 636    struct trace_stream *stream = tr_ctx->stream;
 637    struct pipe_context *pipe = tr_ctx->pipe;
 638
 639    trace_dump_call_begin(stream, "pipe_context", "set_blend_color");
 640
 641    trace_dump_arg(stream, ptr, pipe);
 642    trace_dump_arg(stream, blend_color, state);
 643
 644    pipe->set_blend_color(pipe, state);;
 645
 646    trace_dump_call_end(stream);
 647 }
 648
 649
 650 static INLINE void
 651 trace_context_set_clip_state(struct pipe_context *_pipe,
 652                              const struct pipe_clip_state *state)
 653 {
 654    struct trace_context *tr_ctx = trace_context(_pipe);
 655    struct trace_stream *stream = tr_ctx->stream;
 656    struct pipe_context *pipe = tr_ctx->pipe;
 657
 658    trace_dump_call_begin(stream, "pipe_context", "set_clip_state");
 659
 660    trace_dump_arg(stream, ptr, pipe);
 661    trace_dump_arg(stream, clip_state, state);
 662
 663    pipe->set_clip_state(pipe, state);;
 664
 665    trace_dump_call_end(stream);
 666 }
 667
 668
 669 static INLINE void
 670 trace_context_set_constant_buffer(struct pipe_context *_pipe,
 671                                   uint shader, uint index,
 672                                   const struct pipe_constant_buffer *buffer)
 673 {
 674    struct trace_context *tr_ctx = trace_context(_pipe);
 675    struct trace_stream *stream = tr_ctx->stream;
 676    struct pipe_context *pipe = tr_ctx->pipe;
 677
 678    trace_dump_call_begin(stream, "pipe_context", "set_constant_buffer");
 679
 680    trace_dump_arg(stream, ptr, pipe);
 681    trace_dump_arg(stream, uint, shader);
 682    trace_dump_arg(stream, uint, index);
 683    trace_dump_arg(stream, constant_buffer, buffer);
 684
 685    pipe->set_constant_buffer(pipe, shader, index, buffer);;
 686
 687    trace_dump_call_end(stream);
 688 }
 689
 690
 691 static INLINE void
 692 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
 693                                     const struct pipe_framebuffer_state *state)
 694 {
 695    struct trace_context *tr_ctx = trace_context(_pipe);
 696    struct trace_stream *stream = tr_ctx->stream;
 697    struct pipe_context *pipe = tr_ctx->pipe;
 698
 699    trace_dump_call_begin(stream, "pipe_context", "set_framebuffer_state");
 700
 701    trace_dump_arg(stream, ptr, pipe);
 702    trace_dump_arg(stream, framebuffer_state, state);
 703
 704    pipe->set_framebuffer_state(pipe, state);;
 705
 706    trace_dump_call_end(stream);
 707 }
 708
 709
 710 static INLINE void
 711 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
 712                                   const struct pipe_poly_stipple *state)
 713 {
 714    struct trace_context *tr_ctx = trace_context(_pipe);
 715    struct trace_stream *stream = tr_ctx->stream;
 716    struct pipe_context *pipe = tr_ctx->pipe;
 717
 718    trace_dump_call_begin(stream, "pipe_context", "set_polygon_stipple");
 719
 720    trace_dump_arg(stream, ptr, pipe);
 721    trace_dump_arg(stream, poly_stipple, state);
 722
 723    pipe->set_polygon_stipple(pipe, state);;
 724
 725    trace_dump_call_end(stream);
 726 }
 727
 728
 729 static INLINE void
 730 trace_context_set_scissor_state(struct pipe_context *_pipe,
 731                                 const struct pipe_scissor_state *state)
 732 {
 733    struct trace_context *tr_ctx = trace_context(_pipe);
 734    struct trace_stream *stream = tr_ctx->stream;
 735    struct pipe_context *pipe = tr_ctx->pipe;
 736
 737    trace_dump_call_begin(stream, "pipe_context", "set_scissor_state");
 738
 739    trace_dump_arg(stream, ptr, pipe);
 740    trace_dump_arg(stream, scissor_state, state);
 741
 742    pipe->set_scissor_state(pipe, state);;
 743
 744    trace_dump_call_end(stream);
 745 }
 746
 747
 748 static INLINE void
 749 trace_context_set_viewport_state(struct pipe_context *_pipe,
 750                                  const struct pipe_viewport_state *state)
 751 {
 752    struct trace_context *tr_ctx = trace_context(_pipe);
 753    struct trace_stream *stream = tr_ctx->stream;
 754    struct pipe_context *pipe = tr_ctx->pipe;
 755
 756    trace_dump_call_begin(stream, "pipe_context", "set_viewport_state");
 757
 758    trace_dump_arg(stream, ptr, pipe);
 759    trace_dump_arg(stream, viewport_state, state);
 760
 761    pipe->set_viewport_state(pipe, state);;
 762
 763    trace_dump_call_end(stream);
 764 }
 765
 766
 767 static INLINE void
 768 trace_context_set_sampler_textures(struct pipe_context *_pipe,
 769                                    unsigned num_textures,
 770                                    struct pipe_texture **textures)
 771 {
 772    struct trace_context *tr_ctx = trace_context(_pipe);
 773    struct trace_stream *stream = tr_ctx->stream;
 774    struct pipe_context *pipe = tr_ctx->pipe;
 775
 776    trace_dump_call_begin(stream, "pipe_context", "set_sampler_textures");
 777
 778    trace_dump_arg(stream, ptr, pipe);
 779    trace_dump_arg(stream, uint, num_textures);
 780    trace_dump_arg_array(stream, ptr, textures, num_textures);
 781
 782    pipe->set_sampler_textures(pipe, num_textures, textures);;
 783
 784    trace_dump_call_end(stream);
 785 }
 786
 787
 788 static INLINE void
 789 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
 790                                  unsigned num_buffers,
 791                                  const struct pipe_vertex_buffer *buffers)
 792 {
 793    struct trace_context *tr_ctx = trace_context(_pipe);
 794    struct trace_stream *stream = tr_ctx->stream;
 795    struct pipe_context *pipe = tr_ctx->pipe;
 796
 797    trace_dump_call_begin(stream, "pipe_context", "set_vertex_buffers");
 798
 799    trace_dump_arg(stream, ptr, pipe);
 800    trace_dump_arg(stream, uint, num_buffers);
 801
 802    trace_dump_arg_begin(stream, "buffers");
 803    trace_dump_struct_array(stream, vertex_buffer, buffers, num_buffers);
 804    trace_dump_arg_end(stream);
 805
 806    pipe->set_vertex_buffers(pipe, num_buffers, buffers);;
 807
 808    trace_dump_call_end(stream);
 809 }
 810
 811
 812 static INLINE void
 813 trace_context_set_vertex_elements(struct pipe_context *_pipe,
 814                                   unsigned num_elements,
 815                                   const struct pipe_vertex_element *elements)
 816 {
 817    struct trace_context *tr_ctx = trace_context(_pipe);
 818    struct trace_stream *stream = tr_ctx->stream;
 819    struct pipe_context *pipe = tr_ctx->pipe;
 820
 821    trace_dump_call_begin(stream, "pipe_context", "set_vertex_elements");
 822
 823    trace_dump_arg(stream, ptr, pipe);
 824    trace_dump_arg(stream, uint, num_elements);
 825    trace_dump_arg(stream, ptr, elements);
 826
 827    trace_dump_arg_begin(stream, "elements");
 828    trace_dump_struct_array(stream, vertex_element, elements, num_elements);
 829    trace_dump_arg_end(stream);
 830
 831    pipe->set_vertex_elements(pipe, num_elements, elements);;
 832
 833    trace_dump_call_end(stream);
 834 }
 835
 836
 837 static INLINE void
 838 trace_context_surface_copy(struct pipe_context *_pipe,
 839                            boolean do_flip,
 840                            struct pipe_surface *dest,
 841                            unsigned destx, unsigned desty,
 842                            struct pipe_surface *src,
 843                            unsigned srcx, unsigned srcy,
 844                            unsigned width, unsigned height)
 845 {
 846    struct trace_context *tr_ctx = trace_context(_pipe);
 847    struct trace_stream *stream = tr_ctx->stream;
 848    struct pipe_context *pipe = tr_ctx->pipe;
 849
 850    trace_dump_call_begin(stream, "pipe_context", "surface_copy");
 851
 852    trace_dump_arg(stream, ptr, pipe);
 853    trace_dump_arg(stream, bool, do_flip);
 854    trace_dump_arg(stream, ptr, dest);
 855    trace_dump_arg(stream, uint, destx);
 856    trace_dump_arg(stream, uint, desty);
 857    trace_dump_arg(stream, ptr, src);
 858    trace_dump_arg(stream, uint, srcx);
 859    trace_dump_arg(stream, uint, srcy);
 860    trace_dump_arg(stream, uint, width);
 861    trace_dump_arg(stream, uint, height);
 862
 863    pipe->surface_copy(pipe, do_flip,
 864                       dest, destx, desty,
 865                       src, srcx, srcy, width, height);
 866
 867    trace_dump_call_end(stream);
 868 }
 869
 870
 871 static INLINE void
 872 trace_context_surface_fill(struct pipe_context *_pipe,
 873                            struct pipe_surface *dst,
 874                            unsigned dstx, unsigned dsty,
 875                            unsigned width, unsigned height,
 876                            unsigned value)
 877 {
 878    struct trace_context *tr_ctx = trace_context(_pipe);
 879    struct trace_stream *stream = tr_ctx->stream;
 880    struct pipe_context *pipe = tr_ctx->pipe;
 881
 882    trace_dump_call_begin(stream, "pipe_context", "surface_fill");
 883
 884    trace_dump_arg(stream, ptr, pipe);
 885    trace_dump_arg(stream, ptr, dst);
 886    trace_dump_arg(stream, uint, dstx);
 887    trace_dump_arg(stream, uint, dsty);
 888    trace_dump_arg(stream, uint, width);
 889    trace_dump_arg(stream, uint, height);
 890
 891    pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);;
 892
 893    trace_dump_call_end(stream);
 894 }
 895
 896
 897 static INLINE void
 898 trace_context_clear(struct pipe_context *_pipe,
 899                     struct pipe_surface *surface,
 900                     unsigned clearValue)
 901 {
 902    struct trace_context *tr_ctx = trace_context(_pipe);
 903    struct trace_stream *stream = tr_ctx->stream;
 904    struct pipe_context *pipe = tr_ctx->pipe;
 905
 906    trace_dump_call_begin(stream, "pipe_context", "clear");
 907
 908    trace_dump_arg(stream, ptr, pipe);
 909    trace_dump_arg(stream, ptr, surface);
 910    trace_dump_arg(stream, uint, clearValue);
 911
 912    pipe->clear(pipe, surface, clearValue);;
 913
 914    trace_dump_call_end(stream);
 915 }
 916
 917
 918 static INLINE void
 919 trace_context_flush(struct pipe_context *_pipe,
 920                     unsigned flags,
 921                     struct pipe_fence_handle **fence)
 922 {
 923    struct trace_context *tr_ctx = trace_context(_pipe);
 924    struct trace_stream *stream = tr_ctx->stream;
 925    struct pipe_context *pipe = tr_ctx->pipe;
 926
 927    trace_dump_call_begin(stream, "pipe_context", "flush");
 928
 929    trace_dump_arg(stream, ptr, pipe);
 930    trace_dump_arg(stream, uint, flags);
 931    trace_dump_arg(stream, ptr, fence);
 932
 933    pipe->flush(pipe, flags, fence);;
 934
 935    trace_dump_call_end(stream);
 936 }
 937
 938
 939 static INLINE void
 940 trace_context_destroy(struct pipe_context *_pipe)
 941 {
 942    struct trace_context *tr_ctx = trace_context(_pipe);
 943    struct trace_stream *stream = tr_ctx->stream;
 944    struct pipe_context *pipe = tr_ctx->pipe;
 945
 946    trace_dump_call_begin(stream, "pipe_context", "destroy");
 947
 948    trace_dump_arg(stream, ptr, pipe);
 949
 950    pipe->destroy(pipe);
 951
 952    trace_dump_call_end(stream);
 953
 954    FREE(tr_ctx);
 955 }
 956
 957
 958 struct pipe_context *
 959 trace_context_create(struct pipe_context *pipe)
 960 {
 961    struct trace_stream *stream;
 962    struct trace_context *tr_ctx;
 963
 964    if(!debug_get_bool_option("GALLIUM_TRACE", FALSE))
 965       return pipe;
 966
 967    tr_ctx = CALLOC_STRUCT(trace_context);
 968    if(!tr_ctx)
 969       return NULL;
 970
 971    tr_ctx->base.winsys = pipe->winsys;
 972    tr_ctx->base.screen = pipe->screen;
 973    tr_ctx->base.destroy = trace_context_destroy;
 974    tr_ctx->base.set_edgeflags = trace_context_set_edgeflags;
 975    tr_ctx->base.draw_arrays = trace_context_draw_arrays;
 976    tr_ctx->base.draw_elements = trace_context_draw_elements;
 977    tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
 978    tr_ctx->base.create_query = trace_context_create_query;
 979    tr_ctx->base.destroy_query = trace_context_destroy_query;
 980    tr_ctx->base.begin_query = trace_context_begin_query;
 981    tr_ctx->base.end_query = trace_context_end_query;
 982    tr_ctx->base.get_query_result = trace_context_get_query_result;
 983    tr_ctx->base.create_blend_state = trace_context_create_blend_state;
 984    tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
 985    tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
 986    tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
 987    tr_ctx->base.bind_sampler_states = trace_context_bind_sampler_states;
 988    tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
 989    tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
 990    tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
 991    tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
 992    tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
 993    tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
 994    tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
 995    tr_ctx->base.create_fs_state = trace_context_create_fs_state;
 996    tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
 997    tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
 998    tr_ctx->base.create_vs_state = trace_context_create_vs_state;
 999    tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1000    tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1001    tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1002    tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1003    tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1004    tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1005    tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1006    tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1007    tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1008    tr_ctx->base.set_sampler_textures = trace_context_set_sampler_textures;
1009    tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1010    tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
1011    tr_ctx->base.surface_copy = trace_context_surface_copy;
1012    tr_ctx->base.surface_fill = trace_context_surface_fill;
1013    tr_ctx->base.clear = trace_context_clear;
1014    tr_ctx->base.flush = trace_context_flush;
1015
1016    tr_ctx->pipe = pipe;
1017    tr_ctx->stream = stream = trace_winsys(pipe->winsys)->stream;
1018
1019    /* We don't want to trace the internal pipe calls */
1020    pipe->winsys = trace_winsys(pipe->winsys)->winsys;
1021    pipe->screen = trace_screen(pipe->screen)->screen;
1022
1023    trace_dump_call_begin(stream, "", "pipe_context_create");
1024    trace_dump_arg_begin(stream, "screen");
1025    trace_dump_ptr(stream, pipe->screen);
1026    trace_dump_arg_end(stream);
1027    trace_dump_ret(stream, ptr, pipe);
1028    trace_dump_call_end(stream);
1029
1030    return &tr_ctx->base;
1031 }