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