src/gallium/drivers/trace/tr_context.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "util/u_inlines.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_simple_list.h"
  31 #include "util/u_format.h"
  32
  33 #include "pipe/p_format.h"
  34 #include "pipe/p_screen.h"
  35
  36 #include "tr_dump.h"
  37 #include "tr_dump_state.h"
  38 #include "tr_state.h"
  39 #include "tr_buffer.h"
  40 #include "tr_screen.h"
  41 #include "tr_texture.h"
  42
  43
  44 static INLINE struct pipe_buffer *
  45 trace_buffer_unwrap(struct trace_context *tr_ctx,
  46                      struct pipe_buffer *buffer)
  47 {
  48    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  49    struct trace_buffer *tr_buf;
  50
  51    if(!buffer)
  52       return NULL;
  53
  54    tr_buf = trace_buffer(buffer);
  55
  56    assert(tr_buf->buffer);
  57    assert(tr_buf->buffer->screen == tr_scr->screen);
  58    (void) tr_scr;
  59    return tr_buf->buffer;
  60 }
  61
  62
  63 static INLINE struct pipe_texture *
  64 trace_texture_unwrap(struct trace_context *tr_ctx,
  65                      struct pipe_texture *texture)
  66 {
  67    struct trace_texture *tr_tex;
  68
  69    if(!texture)
  70       return NULL;
  71
  72    tr_tex = trace_texture(texture);
  73
  74    assert(tr_tex->texture);
  75    return tr_tex->texture;
  76 }
  77
  78
  79 static INLINE struct pipe_surface *
  80 trace_surface_unwrap(struct trace_context *tr_ctx,
  81                      struct pipe_surface *surface)
  82 {
  83    struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
  84    struct trace_surface *tr_surf;
  85
  86    if(!surface)
  87       return NULL;
  88
  89    assert(surface->texture);
  90    if(!surface->texture)
  91       return surface;
  92
  93    tr_surf = trace_surface(surface);
  94
  95    assert(tr_surf->surface);
  96    assert(tr_surf->surface->texture->screen == tr_scr->screen);
  97    (void) tr_scr;
  98    return tr_surf->surface;
  99 }
 100
 101
 102 static INLINE void
 103 trace_context_draw_block(struct trace_context *tr_ctx, int flag)
 104 {
 105    int k;
 106
 107    pipe_mutex_lock(tr_ctx->draw_mutex);
 108
 109    if (tr_ctx->draw_blocker & flag) {
 110       tr_ctx->draw_blocked |= flag;
 111    } else if ((tr_ctx->draw_rule.blocker & flag) &&
 112               (tr_ctx->draw_blocker & 4)) {
 113       boolean block = FALSE;
 114       debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
 115                    (void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
 116                    (void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
 117                    (void *) tr_ctx->draw_rule.surf, 0,
 118                    (void *) tr_ctx->draw_rule.sampler_view, 0);
 119       if (tr_ctx->draw_rule.fs &&
 120           tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
 121          block = TRUE;
 122       if (tr_ctx->draw_rule.vs &&
 123           tr_ctx->draw_rule.vs == tr_ctx->curr.vs)
 124          block = TRUE;
 125       if (tr_ctx->draw_rule.surf &&
 126           tr_ctx->draw_rule.surf == tr_ctx->curr.zsbuf)
 127             block = TRUE;
 128       if (tr_ctx->draw_rule.surf)
 129          for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
 130             if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
 131                block = TRUE;
 132       if (tr_ctx->draw_rule.sampler_view) {
 133          for (k = 0; k < tr_ctx->curr.num_sampler_views; k++)
 134             if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.sampler_views[k])
 135                block = TRUE;
 136          for (k = 0; k < tr_ctx->curr.num_vert_sampler_views; k++) {
 137             if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.vert_sampler_views[k]) {
 138                block = TRUE;
 139             }
 140          }
 141       }
 142
 143       if (block)
 144          tr_ctx->draw_blocked |= (flag | 4);
 145    }
 146
 147    if (tr_ctx->draw_blocked)
 148       trace_rbug_notify_draw_blocked(tr_ctx);
 149
 150    /* wait for rbug to clear the blocked flag */
 151    while (tr_ctx->draw_blocked & flag) {
 152       tr_ctx->draw_blocked |= flag;
 153 #ifdef PIPE_THREAD_HAVE_CONDVAR
 154       pipe_condvar_wait(tr_ctx->draw_cond, tr_ctx->draw_mutex);
 155 #else
 156       pipe_mutex_unlock(tr_ctx->draw_mutex);
 157 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
 158       Sleep(1);
 159 #endif
 160       pipe_mutex_lock(tr_ctx->draw_mutex);
 161 #endif
 162    }
 163
 164    pipe_mutex_unlock(tr_ctx->draw_mutex);
 165 }
 166
 167 static INLINE void
 168 trace_context_draw_arrays(struct pipe_context *_pipe,
 169                           unsigned mode, unsigned start, unsigned count)
 170 {
 171    struct trace_context *tr_ctx = trace_context(_pipe);
 172    struct pipe_context *pipe = tr_ctx->pipe;
 173
 174    if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
 175       return;
 176
 177    trace_context_draw_block(tr_ctx, 1);
 178
 179    trace_dump_call_begin("pipe_context", "draw_arrays");
 180
 181    trace_dump_arg(ptr, pipe);
 182    trace_dump_arg(uint, mode);
 183    trace_dump_arg(uint, start);
 184    trace_dump_arg(uint, count);
 185
 186    pipe->draw_arrays(pipe, mode, start, count);
 187
 188    trace_dump_call_end();
 189
 190    trace_context_draw_block(tr_ctx, 2);
 191 }
 192
 193
 194 static INLINE void
 195 trace_context_draw_elements(struct pipe_context *_pipe,
 196                           struct pipe_buffer *_indexBuffer,
 197                           unsigned indexSize,
 198                           unsigned mode, unsigned start, unsigned count)
 199 {
 200    struct trace_context *tr_ctx = trace_context(_pipe);
 201    struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
 202    struct pipe_context *pipe = tr_ctx->pipe;
 203    struct pipe_buffer *indexBuffer = tr_buf->buffer;
 204
 205    if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
 206       return;
 207
 208    trace_context_draw_block(tr_ctx, 1);
 209
 210    trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
 211
 212    trace_dump_call_begin("pipe_context", "draw_elements");
 213
 214    trace_dump_arg(ptr, pipe);
 215    trace_dump_arg(ptr, indexBuffer);
 216    trace_dump_arg(uint, indexSize);
 217    trace_dump_arg(uint, mode);
 218    trace_dump_arg(uint, start);
 219    trace_dump_arg(uint, count);
 220
 221    pipe->draw_elements(pipe, indexBuffer, indexSize, mode, start, count);
 222
 223    trace_dump_call_end();
 224
 225    trace_context_draw_block(tr_ctx, 2);
 226 }
 227
 228
 229 static INLINE void
 230 trace_context_draw_range_elements(struct pipe_context *_pipe,
 231                                   struct pipe_buffer *_indexBuffer,
 232                                   unsigned indexSize,
 233                                   unsigned minIndex,
 234                                   unsigned maxIndex,
 235                                   unsigned mode,
 236                                   unsigned start,
 237                                   unsigned count)
 238 {
 239    struct trace_context *tr_ctx = trace_context(_pipe);
 240    struct trace_buffer *tr_buf = trace_buffer(_indexBuffer);
 241    struct pipe_context *pipe = tr_ctx->pipe;
 242    struct pipe_buffer *indexBuffer = tr_buf->buffer;
 243
 244    if (tr_ctx->curr.fs->disabled || tr_ctx->curr.vs->disabled)
 245       return;
 246
 247    trace_context_draw_block(tr_ctx, 1);
 248
 249    trace_screen_user_buffer_update(_pipe->screen, indexBuffer);
 250
 251    trace_dump_call_begin("pipe_context", "draw_range_elements");
 252
 253    trace_dump_arg(ptr, pipe);
 254    trace_dump_arg(ptr, indexBuffer);
 255    trace_dump_arg(uint, indexSize);
 256    trace_dump_arg(uint, minIndex);
 257    trace_dump_arg(uint, maxIndex);
 258    trace_dump_arg(uint, mode);
 259    trace_dump_arg(uint, start);
 260    trace_dump_arg(uint, count);
 261
 262    pipe->draw_range_elements(pipe,
 263                              indexBuffer,
 264                              indexSize, minIndex, maxIndex,
 265                              mode, start, count);
 266
 267    trace_dump_call_end();
 268
 269    trace_context_draw_block(tr_ctx, 2);
 270 }
 271
 272
 273 static INLINE struct pipe_query *
 274 trace_context_create_query(struct pipe_context *_pipe,
 275                            unsigned query_type)
 276 {
 277    struct trace_context *tr_ctx = trace_context(_pipe);
 278    struct pipe_context *pipe = tr_ctx->pipe;
 279    struct pipe_query *result;
 280
 281    trace_dump_call_begin("pipe_context", "create_query");
 282
 283    trace_dump_arg(ptr, pipe);
 284    trace_dump_arg(uint, query_type);
 285
 286    result = pipe->create_query(pipe, query_type);
 287
 288    trace_dump_ret(ptr, result);
 289
 290    trace_dump_call_end();
 291
 292    return result;
 293 }
 294
 295
 296 static INLINE void
 297 trace_context_destroy_query(struct pipe_context *_pipe,
 298                             struct pipe_query *query)
 299 {
 300    struct trace_context *tr_ctx = trace_context(_pipe);
 301    struct pipe_context *pipe = tr_ctx->pipe;
 302
 303    trace_dump_call_begin("pipe_context", "destroy_query");
 304
 305    trace_dump_arg(ptr, pipe);
 306    trace_dump_arg(ptr, query);
 307
 308    pipe->destroy_query(pipe, query);
 309
 310    trace_dump_call_end();
 311 }
 312
 313
 314 static INLINE void
 315 trace_context_begin_query(struct pipe_context *_pipe,
 316                           struct pipe_query *query)
 317 {
 318    struct trace_context *tr_ctx = trace_context(_pipe);
 319    struct pipe_context *pipe = tr_ctx->pipe;
 320
 321    trace_dump_call_begin("pipe_context", "begin_query");
 322
 323    trace_dump_arg(ptr, pipe);
 324    trace_dump_arg(ptr, query);
 325
 326    pipe->begin_query(pipe, query);
 327
 328    trace_dump_call_end();
 329 }
 330
 331
 332 static INLINE void
 333 trace_context_end_query(struct pipe_context *_pipe,
 334                         struct pipe_query *query)
 335 {
 336    struct trace_context *tr_ctx = trace_context(_pipe);
 337    struct pipe_context *pipe = tr_ctx->pipe;
 338
 339    trace_dump_call_begin("pipe_context", "end_query");
 340
 341    trace_dump_arg(ptr, pipe);
 342    trace_dump_arg(ptr, query);
 343
 344    pipe->end_query(pipe, query);
 345
 346    trace_dump_call_end();
 347 }
 348
 349
 350 static INLINE boolean
 351 trace_context_get_query_result(struct pipe_context *_pipe,
 352                                struct pipe_query *query,
 353                                boolean wait,
 354                                uint64_t *presult)
 355 {
 356    struct trace_context *tr_ctx = trace_context(_pipe);
 357    struct pipe_context *pipe = tr_ctx->pipe;
 358    uint64_t result;
 359    boolean _result;
 360
 361    trace_dump_call_begin("pipe_context", "get_query_result");
 362
 363    trace_dump_arg(ptr, pipe);
 364
 365    _result = pipe->get_query_result(pipe, query, wait, presult);
 366    result = *presult;
 367
 368    trace_dump_arg(uint, result);
 369    trace_dump_ret(bool, _result);
 370
 371    trace_dump_call_end();
 372
 373    return _result;
 374 }
 375
 376
 377 static INLINE void *
 378 trace_context_create_blend_state(struct pipe_context *_pipe,
 379                                  const struct pipe_blend_state *state)
 380 {
 381    struct trace_context *tr_ctx = trace_context(_pipe);
 382    struct pipe_context *pipe = tr_ctx->pipe;
 383    void * result;
 384
 385    trace_dump_call_begin("pipe_context", "create_blend_state");
 386
 387    trace_dump_arg(ptr, pipe);
 388    trace_dump_arg(blend_state, state);
 389
 390    result = pipe->create_blend_state(pipe, state);
 391
 392    trace_dump_ret(ptr, result);
 393
 394    trace_dump_call_end();
 395
 396    return result;
 397 }
 398
 399
 400 static INLINE void
 401 trace_context_bind_blend_state(struct pipe_context *_pipe,
 402                                void *state)
 403 {
 404    struct trace_context *tr_ctx = trace_context(_pipe);
 405    struct pipe_context *pipe = tr_ctx->pipe;
 406
 407    trace_dump_call_begin("pipe_context", "bind_blend_state");
 408
 409    trace_dump_arg(ptr, pipe);
 410    trace_dump_arg(ptr, state);
 411
 412    pipe->bind_blend_state(pipe, state);
 413
 414    trace_dump_call_end();
 415 }
 416
 417
 418 static INLINE void
 419 trace_context_delete_blend_state(struct pipe_context *_pipe,
 420                                  void *state)
 421 {
 422    struct trace_context *tr_ctx = trace_context(_pipe);
 423    struct pipe_context *pipe = tr_ctx->pipe;
 424
 425    trace_dump_call_begin("pipe_context", "delete_blend_state");
 426
 427    trace_dump_arg(ptr, pipe);
 428    trace_dump_arg(ptr, state);
 429
 430    pipe->delete_blend_state(pipe, state);
 431
 432    trace_dump_call_end();
 433 }
 434
 435
 436 static INLINE void *
 437 trace_context_create_sampler_state(struct pipe_context *_pipe,
 438                                    const struct pipe_sampler_state *state)
 439 {
 440    struct trace_context *tr_ctx = trace_context(_pipe);
 441    struct pipe_context *pipe = tr_ctx->pipe;
 442    void * result;
 443
 444    trace_dump_call_begin("pipe_context", "create_sampler_state");
 445
 446    trace_dump_arg(ptr, pipe);
 447    trace_dump_arg(sampler_state, state);
 448
 449    result = pipe->create_sampler_state(pipe, state);
 450
 451    trace_dump_ret(ptr, result);
 452
 453    trace_dump_call_end();
 454
 455    return result;
 456 }
 457
 458
 459 static INLINE void
 460 trace_context_bind_fragment_sampler_states(struct pipe_context *_pipe,
 461                                            unsigned num_states,
 462                                            void **states)
 463 {
 464    struct trace_context *tr_ctx = trace_context(_pipe);
 465    struct pipe_context *pipe = tr_ctx->pipe;
 466
 467    trace_dump_call_begin("pipe_context", "bind_fragment_sampler_states");
 468
 469    trace_dump_arg(ptr, pipe);
 470    trace_dump_arg(uint, num_states);
 471    trace_dump_arg_array(ptr, states, num_states);
 472
 473    pipe->bind_fragment_sampler_states(pipe, num_states, states);
 474
 475    trace_dump_call_end();
 476 }
 477
 478
 479 static INLINE void
 480 trace_context_bind_vertex_sampler_states(struct pipe_context *_pipe,
 481                                          unsigned num_states,
 482                                          void **states)
 483 {
 484    struct trace_context *tr_ctx = trace_context(_pipe);
 485    struct pipe_context *pipe = tr_ctx->pipe;
 486
 487    trace_dump_call_begin("pipe_context", "bind_vertex_sampler_states");
 488
 489    trace_dump_arg(ptr, pipe);
 490    trace_dump_arg(uint, num_states);
 491    trace_dump_arg_array(ptr, states, num_states);
 492
 493    pipe->bind_vertex_sampler_states(pipe, num_states, states);
 494
 495    trace_dump_call_end();
 496 }
 497
 498
 499 static INLINE void
 500 trace_context_delete_sampler_state(struct pipe_context *_pipe,
 501                                    void *state)
 502 {
 503    struct trace_context *tr_ctx = trace_context(_pipe);
 504    struct pipe_context *pipe = tr_ctx->pipe;
 505
 506    trace_dump_call_begin("pipe_context", "delete_sampler_state");
 507
 508    trace_dump_arg(ptr, pipe);
 509    trace_dump_arg(ptr, state);
 510
 511    pipe->delete_sampler_state(pipe, state);
 512
 513    trace_dump_call_end();
 514 }
 515
 516
 517 static INLINE void *
 518 trace_context_create_rasterizer_state(struct pipe_context *_pipe,
 519                                       const struct pipe_rasterizer_state *state)
 520 {
 521    struct trace_context *tr_ctx = trace_context(_pipe);
 522    struct pipe_context *pipe = tr_ctx->pipe;
 523    void * result;
 524
 525    trace_dump_call_begin("pipe_context", "create_rasterizer_state");
 526
 527    trace_dump_arg(ptr, pipe);
 528    trace_dump_arg(rasterizer_state, state);
 529
 530    result = pipe->create_rasterizer_state(pipe, state);
 531
 532    trace_dump_ret(ptr, result);
 533
 534    trace_dump_call_end();
 535
 536    return result;
 537 }
 538
 539
 540 static INLINE void
 541 trace_context_bind_rasterizer_state(struct pipe_context *_pipe,
 542                                     void *state)
 543 {
 544    struct trace_context *tr_ctx = trace_context(_pipe);
 545    struct pipe_context *pipe = tr_ctx->pipe;
 546
 547    trace_dump_call_begin("pipe_context", "bind_rasterizer_state");
 548
 549    trace_dump_arg(ptr, pipe);
 550    trace_dump_arg(ptr, state);
 551
 552    pipe->bind_rasterizer_state(pipe, state);
 553
 554    trace_dump_call_end();
 555 }
 556
 557
 558 static INLINE void
 559 trace_context_delete_rasterizer_state(struct pipe_context *_pipe,
 560                                       void *state)
 561 {
 562    struct trace_context *tr_ctx = trace_context(_pipe);
 563    struct pipe_context *pipe = tr_ctx->pipe;
 564
 565    trace_dump_call_begin("pipe_context", "delete_rasterizer_state");
 566
 567    trace_dump_arg(ptr, pipe);
 568    trace_dump_arg(ptr, state);
 569
 570    pipe->delete_rasterizer_state(pipe, state);
 571
 572    trace_dump_call_end();
 573 }
 574
 575
 576 static INLINE void *
 577 trace_context_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 578                                                const struct pipe_depth_stencil_alpha_state *state)
 579 {
 580    struct trace_context *tr_ctx = trace_context(_pipe);
 581    struct pipe_context *pipe = tr_ctx->pipe;
 582    void * result;
 583
 584    trace_dump_call_begin("pipe_context", "create_depth_stencil_alpha_state");
 585
 586    result = pipe->create_depth_stencil_alpha_state(pipe, state);
 587
 588    trace_dump_arg(ptr, pipe);
 589    trace_dump_arg(depth_stencil_alpha_state, state);
 590
 591    trace_dump_ret(ptr, result);
 592
 593    trace_dump_call_end();
 594
 595    return result;
 596 }
 597
 598
 599 static INLINE void
 600 trace_context_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 601                                              void *state)
 602 {
 603    struct trace_context *tr_ctx = trace_context(_pipe);
 604    struct pipe_context *pipe = tr_ctx->pipe;
 605
 606    trace_dump_call_begin("pipe_context", "bind_depth_stencil_alpha_state");
 607
 608    trace_dump_arg(ptr, pipe);
 609    trace_dump_arg(ptr, state);
 610
 611    pipe->bind_depth_stencil_alpha_state(pipe, state);
 612
 613    trace_dump_call_end();
 614 }
 615
 616
 617 static INLINE void
 618 trace_context_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 619                                                void *state)
 620 {
 621    struct trace_context *tr_ctx = trace_context(_pipe);
 622    struct pipe_context *pipe = tr_ctx->pipe;
 623
 624    trace_dump_call_begin("pipe_context", "delete_depth_stencil_alpha_state");
 625
 626    trace_dump_arg(ptr, pipe);
 627    trace_dump_arg(ptr, state);
 628
 629    pipe->delete_depth_stencil_alpha_state(pipe, state);
 630
 631    trace_dump_call_end();
 632 }
 633
 634
 635 static INLINE void *
 636 trace_context_create_fs_state(struct pipe_context *_pipe,
 637                               const struct pipe_shader_state *state)
 638 {
 639    struct trace_context *tr_ctx = trace_context(_pipe);
 640    struct pipe_context *pipe = tr_ctx->pipe;
 641    void * result;
 642
 643    trace_dump_call_begin("pipe_context", "create_fs_state");
 644
 645    trace_dump_arg(ptr, pipe);
 646    trace_dump_arg(shader_state, state);
 647
 648    result = pipe->create_fs_state(pipe, state);
 649
 650    trace_dump_ret(ptr, result);
 651
 652    trace_dump_call_end();
 653
 654    result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_FRAGMENT);
 655
 656    return result;
 657 }
 658
 659
 660 static INLINE void
 661 trace_context_bind_fs_state(struct pipe_context *_pipe,
 662                             void *_state)
 663 {
 664    struct trace_context *tr_ctx = trace_context(_pipe);
 665    struct trace_shader *tr_shdr = trace_shader(_state);
 666    struct pipe_context *pipe = tr_ctx->pipe;
 667    void *state = tr_shdr ? tr_shdr->state : NULL;
 668
 669    trace_dump_call_begin("pipe_context", "bind_fs_state");
 670
 671    trace_dump_arg(ptr, pipe);
 672    trace_dump_arg(ptr, state);
 673
 674    tr_ctx->curr.fs = tr_shdr;
 675
 676    if (tr_shdr && tr_shdr->replaced)
 677       state = tr_shdr->replaced;
 678
 679    pipe->bind_fs_state(pipe, state);
 680
 681    trace_dump_call_end();
 682 }
 683
 684
 685 static INLINE void
 686 trace_context_delete_fs_state(struct pipe_context *_pipe,
 687                               void *_state)
 688 {
 689    struct trace_context *tr_ctx = trace_context(_pipe);
 690    struct trace_shader *tr_shdr = trace_shader(_state);
 691    struct pipe_context *pipe = tr_ctx->pipe;
 692    void *state = tr_shdr->state;
 693
 694    trace_dump_call_begin("pipe_context", "delete_fs_state");
 695
 696    trace_dump_arg(ptr, pipe);
 697    trace_dump_arg(ptr, state);
 698
 699    pipe->delete_fs_state(pipe, state);
 700
 701    trace_dump_call_end();
 702
 703    trace_shader_destroy(tr_ctx, tr_shdr);
 704 }
 705
 706
 707 static INLINE void *
 708 trace_context_create_vs_state(struct pipe_context *_pipe,
 709                               const struct pipe_shader_state *state)
 710 {
 711    struct trace_context *tr_ctx = trace_context(_pipe);
 712    struct pipe_context *pipe = tr_ctx->pipe;
 713    void * result;
 714
 715    trace_dump_call_begin("pipe_context", "create_vs_state");
 716
 717    trace_dump_arg(ptr, pipe);
 718    trace_dump_arg(shader_state, state);
 719
 720    result = pipe->create_vs_state(pipe, state);
 721
 722    trace_dump_ret(ptr, result);
 723
 724    trace_dump_call_end();
 725
 726    result = trace_shader_create(tr_ctx, state, result, TRACE_SHADER_VERTEX);
 727
 728    return result;
 729 }
 730
 731
 732 static INLINE void
 733 trace_context_bind_vs_state(struct pipe_context *_pipe,
 734                             void *_state)
 735 {
 736    struct trace_context *tr_ctx = trace_context(_pipe);
 737    struct trace_shader *tr_shdr = trace_shader(_state);
 738    struct pipe_context *pipe = tr_ctx->pipe;
 739    void *state = tr_shdr ? tr_shdr->state : NULL;
 740
 741    trace_dump_call_begin("pipe_context", "bind_vs_state");
 742
 743    trace_dump_arg(ptr, pipe);
 744    trace_dump_arg(ptr, state);
 745
 746    tr_ctx->curr.vs = tr_shdr;
 747
 748    if (tr_shdr && tr_shdr->replaced)
 749       state = tr_shdr->replaced;
 750
 751    pipe->bind_vs_state(pipe, state);
 752
 753    trace_dump_call_end();
 754 }
 755
 756
 757 static INLINE void
 758 trace_context_delete_vs_state(struct pipe_context *_pipe,
 759                               void *_state)
 760 {
 761    struct trace_context *tr_ctx = trace_context(_pipe);
 762    struct trace_shader *tr_shdr = trace_shader(_state);
 763    struct pipe_context *pipe = tr_ctx->pipe;
 764    void *state = tr_shdr->state;
 765
 766    trace_dump_call_begin("pipe_context", "delete_vs_state");
 767
 768    trace_dump_arg(ptr, pipe);
 769    trace_dump_arg(ptr, state);
 770
 771    pipe->delete_vs_state(pipe, state);
 772
 773    trace_dump_call_end();
 774
 775    trace_shader_destroy(tr_ctx, tr_shdr);
 776 }
 777
 778
 779 static INLINE void *
 780 trace_context_create_vertex_elements_state(struct pipe_context *_pipe,
 781                                            unsigned num_elements,
 782                                            const struct  pipe_vertex_element *elements)
 783 {
 784    struct trace_context *tr_ctx = trace_context(_pipe);
 785    struct pipe_context *pipe = tr_ctx->pipe;
 786    void * result;
 787
 788    trace_dump_call_begin("pipe_context", "create_vertex_elements_state");
 789
 790    trace_dump_arg(ptr, pipe);
 791    trace_dump_arg(uint, num_elements);
 792
 793    trace_dump_arg_begin("elements");
 794    trace_dump_struct_array(vertex_element, elements, num_elements);
 795    trace_dump_arg_end();
 796
 797    result = pipe->create_vertex_elements_state(pipe, num_elements, elements);
 798
 799    trace_dump_ret(ptr, result);
 800
 801    trace_dump_call_end();
 802
 803    return result;
 804 }
 805
 806
 807 static INLINE void
 808 trace_context_bind_vertex_elements_state(struct pipe_context *_pipe,
 809                                          void *state)
 810 {
 811    struct trace_context *tr_ctx = trace_context(_pipe);
 812    struct pipe_context *pipe = tr_ctx->pipe;
 813
 814    trace_dump_call_begin("pipe_context", "bind_vertex_elements_state");
 815
 816    trace_dump_arg(ptr, pipe);
 817    trace_dump_arg(ptr, state);
 818
 819    pipe->bind_vertex_elements_state(pipe, state);
 820
 821    trace_dump_call_end();
 822 }
 823
 824
 825 static INLINE void
 826 trace_context_delete_vertex_elements_state(struct pipe_context *_pipe,
 827                                            void *state)
 828 {
 829    struct trace_context *tr_ctx = trace_context(_pipe);
 830    struct pipe_context *pipe = tr_ctx->pipe;
 831
 832    trace_dump_call_begin("pipe_context", "delete_verte_elements_state");
 833
 834    trace_dump_arg(ptr, pipe);
 835    trace_dump_arg(ptr, state);
 836
 837    pipe->delete_vertex_elements_state(pipe, state);
 838
 839    trace_dump_call_end();
 840 }
 841
 842
 843 static INLINE void
 844 trace_context_set_blend_color(struct pipe_context *_pipe,
 845                               const struct pipe_blend_color *state)
 846 {
 847    struct trace_context *tr_ctx = trace_context(_pipe);
 848    struct pipe_context *pipe = tr_ctx->pipe;
 849
 850    trace_dump_call_begin("pipe_context", "set_blend_color");
 851
 852    trace_dump_arg(ptr, pipe);
 853    trace_dump_arg(blend_color, state);
 854
 855    pipe->set_blend_color(pipe, state);
 856
 857    trace_dump_call_end();
 858 }
 859
 860
 861 static INLINE void
 862 trace_context_set_stencil_ref(struct pipe_context *_pipe,
 863                               const struct pipe_stencil_ref *state)
 864 {
 865    struct trace_context *tr_ctx = trace_context(_pipe);
 866    struct pipe_context *pipe = tr_ctx->pipe;
 867
 868    trace_dump_call_begin("pipe_context", "set_stencil_ref");
 869
 870    trace_dump_arg(ptr, pipe);
 871    trace_dump_arg(stencil_ref, state);
 872
 873    pipe->set_stencil_ref(pipe, state);
 874
 875    trace_dump_call_end();
 876 }
 877
 878
 879 static INLINE void
 880 trace_context_set_clip_state(struct pipe_context *_pipe,
 881                              const struct pipe_clip_state *state)
 882 {
 883    struct trace_context *tr_ctx = trace_context(_pipe);
 884    struct pipe_context *pipe = tr_ctx->pipe;
 885
 886    trace_dump_call_begin("pipe_context", "set_clip_state");
 887
 888    trace_dump_arg(ptr, pipe);
 889    trace_dump_arg(clip_state, state);
 890
 891    pipe->set_clip_state(pipe, state);
 892
 893    trace_dump_call_end();
 894 }
 895
 896
 897 static INLINE void
 898 trace_context_set_constant_buffer(struct pipe_context *_pipe,
 899                                   uint shader, uint index,
 900                                   struct pipe_buffer *buffer)
 901 {
 902    struct trace_context *tr_ctx = trace_context(_pipe);
 903    struct pipe_context *pipe = tr_ctx->pipe;
 904
 905    if (buffer) {
 906       trace_screen_user_buffer_update(_pipe->screen, buffer);
 907       buffer = trace_buffer_unwrap(tr_ctx, buffer);
 908    }
 909
 910    trace_dump_call_begin("pipe_context", "set_constant_buffer");
 911
 912    trace_dump_arg(ptr, pipe);
 913    trace_dump_arg(uint, shader);
 914    trace_dump_arg(uint, index);
 915    trace_dump_arg(ptr, buffer);
 916
 917    pipe->set_constant_buffer(pipe, shader, index, buffer);
 918
 919    trace_dump_call_end();
 920 }
 921
 922
 923 static INLINE void
 924 trace_context_set_framebuffer_state(struct pipe_context *_pipe,
 925                                     const struct pipe_framebuffer_state *state)
 926 {
 927    struct trace_context *tr_ctx = trace_context(_pipe);
 928    struct pipe_context *pipe = tr_ctx->pipe;
 929    struct pipe_framebuffer_state unwrapped_state;
 930    unsigned i;
 931
 932    {
 933       tr_ctx->curr.nr_cbufs = state->nr_cbufs;
 934       for (i = 0; i < state->nr_cbufs; i++)
 935          if (state->cbufs[i])
 936             tr_ctx->curr.cbufs[i] = trace_texture(state->cbufs[i]->texture);
 937          else
 938             tr_ctx->curr.cbufs[i] = NULL;
 939       if (state->zsbuf)
 940          tr_ctx->curr.zsbuf = trace_texture(state->zsbuf->texture);
 941       else
 942          tr_ctx->curr.zsbuf = NULL;
 943    }
 944
 945    /* Unwrap the input state */
 946    memcpy(&unwrapped_state, state, sizeof(unwrapped_state));
 947    for(i = 0; i < state->nr_cbufs; ++i)
 948       unwrapped_state.cbufs[i] = trace_surface_unwrap(tr_ctx, state->cbufs[i]);
 949    for(i = state->nr_cbufs; i < PIPE_MAX_COLOR_BUFS; ++i)
 950       unwrapped_state.cbufs[i] = NULL;
 951    unwrapped_state.zsbuf = trace_surface_unwrap(tr_ctx, state->zsbuf);
 952    state = &unwrapped_state;
 953
 954    trace_dump_call_begin("pipe_context", "set_framebuffer_state");
 955
 956    trace_dump_arg(ptr, pipe);
 957    trace_dump_arg(framebuffer_state, state);
 958
 959    pipe->set_framebuffer_state(pipe, state);
 960
 961    trace_dump_call_end();
 962 }
 963
 964
 965 static INLINE void
 966 trace_context_set_polygon_stipple(struct pipe_context *_pipe,
 967                                   const struct pipe_poly_stipple *state)
 968 {
 969    struct trace_context *tr_ctx = trace_context(_pipe);
 970    struct pipe_context *pipe = tr_ctx->pipe;
 971
 972    trace_dump_call_begin("pipe_context", "set_polygon_stipple");
 973
 974    trace_dump_arg(ptr, pipe);
 975    trace_dump_arg(poly_stipple, state);
 976
 977    pipe->set_polygon_stipple(pipe, state);
 978
 979    trace_dump_call_end();
 980 }
 981
 982
 983 static INLINE void
 984 trace_context_set_scissor_state(struct pipe_context *_pipe,
 985                                 const struct pipe_scissor_state *state)
 986 {
 987    struct trace_context *tr_ctx = trace_context(_pipe);
 988    struct pipe_context *pipe = tr_ctx->pipe;
 989
 990    trace_dump_call_begin("pipe_context", "set_scissor_state");
 991
 992    trace_dump_arg(ptr, pipe);
 993    trace_dump_arg(scissor_state, state);
 994
 995    pipe->set_scissor_state(pipe, state);
 996
 997    trace_dump_call_end();
 998 }
 999
1000
1001 static INLINE void
1002 trace_context_set_viewport_state(struct pipe_context *_pipe,
1003                                  const struct pipe_viewport_state *state)
1004 {
1005    struct trace_context *tr_ctx = trace_context(_pipe);
1006    struct pipe_context *pipe = tr_ctx->pipe;
1007
1008    trace_dump_call_begin("pipe_context", "set_viewport_state");
1009
1010    trace_dump_arg(ptr, pipe);
1011    trace_dump_arg(viewport_state, state);
1012
1013    pipe->set_viewport_state(pipe, state);
1014
1015    trace_dump_call_end();
1016 }
1017
1018
1019 static struct pipe_sampler_view *
1020 trace_create_sampler_view(struct pipe_context *_pipe,
1021                           struct pipe_texture *_texture,
1022                           const struct pipe_sampler_view *templ)
1023 {
1024    struct trace_context *tr_ctx = trace_context(_pipe);
1025    struct trace_texture *tr_tex = trace_texture(_texture);
1026    struct pipe_context *pipe = tr_ctx->pipe;
1027    struct pipe_texture *texture = tr_tex->texture;
1028    struct trace_sampler_view *result = CALLOC_STRUCT(trace_sampler_view);
1029
1030    trace_dump_call_begin("pipe_context", "create_sampler_view");
1031
1032    trace_dump_arg(ptr, pipe);
1033    trace_dump_arg(ptr, texture);
1034    trace_dump_arg(ptr, templ);
1035
1036    result->sampler_view = pipe->create_sampler_view(pipe, texture, templ);
1037
1038    result->base = *templ;
1039    result->base.reference.count = 1;
1040    result->base.texture = NULL;
1041    pipe_texture_reference(&result->base.texture, _texture);
1042    result->base.context = _pipe;
1043
1044    trace_dump_ret(ptr, result);
1045
1046    trace_dump_call_end();
1047
1048    return &result->base;
1049 }
1050
1051
1052 static void
1053 trace_sampler_view_destroy(struct pipe_context *_pipe,
1054                            struct pipe_sampler_view *_view)
1055 {
1056    struct trace_context *tr_ctx = trace_context(_pipe);
1057    struct trace_sampler_view *tr_view = trace_sampler_view(_view);
1058    struct pipe_context *pipe = tr_ctx->pipe;
1059    struct pipe_sampler_view *view = tr_view->sampler_view;
1060
1061    trace_dump_call_begin("pipe_context", "sampler_view_destroy");
1062
1063    trace_dump_arg(ptr, pipe);
1064    trace_dump_arg(ptr, view);
1065
1066    pipe->sampler_view_destroy(pipe, view);
1067
1068    trace_dump_call_end();
1069
1070    pipe_texture_reference(&_view->texture, NULL);
1071    FREE(_view);
1072 }
1073
1074
1075 static INLINE void
1076 trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
1077                                          unsigned num,
1078                                          struct pipe_sampler_view **views)
1079 {
1080    struct trace_context *tr_ctx = trace_context(_pipe);
1081    struct trace_sampler_view *tr_view;
1082    struct pipe_context *pipe = tr_ctx->pipe;
1083    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
1084    unsigned i;
1085
1086    tr_ctx->curr.num_sampler_views = num;
1087    for(i = 0; i < num; ++i) {
1088       tr_view = trace_sampler_view(views[i]);
1089       tr_ctx->curr.sampler_views[i] = tr_view;
1090       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1091    }
1092    views = unwrapped_views;
1093
1094    trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
1095
1096    trace_dump_arg(ptr, pipe);
1097    trace_dump_arg(uint, num);
1098    trace_dump_arg_array(ptr, views, num);
1099
1100    pipe->set_fragment_sampler_views(pipe, num, views);
1101
1102    trace_dump_call_end();
1103 }
1104
1105
1106 static INLINE void
1107 trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
1108                                        unsigned num,
1109                                        struct pipe_sampler_view **views)
1110 {
1111    struct trace_context *tr_ctx = trace_context(_pipe);
1112    struct trace_sampler_view *tr_view;
1113    struct pipe_context *pipe = tr_ctx->pipe;
1114    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
1115    unsigned i;
1116
1117    tr_ctx->curr.num_vert_sampler_views = num;
1118    for(i = 0; i < num; ++i) {
1119       tr_view = trace_sampler_view(views[i]);
1120       tr_ctx->curr.vert_sampler_views[i] = tr_view;
1121       unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
1122    }
1123    views = unwrapped_views;
1124
1125    trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
1126
1127    trace_dump_arg(ptr, pipe);
1128    trace_dump_arg(uint, num);
1129    trace_dump_arg_array(ptr, views, num);
1130
1131    pipe->set_vertex_sampler_views(pipe, num, views);
1132
1133    trace_dump_call_end();
1134 }
1135
1136
1137 static INLINE void
1138 trace_context_set_vertex_buffers(struct pipe_context *_pipe,
1139                                  unsigned num_buffers,
1140                                  const struct pipe_vertex_buffer *buffers)
1141 {
1142    struct trace_context *tr_ctx = trace_context(_pipe);
1143    struct pipe_context *pipe = tr_ctx->pipe;
1144    unsigned i;
1145
1146    for(i = 0; i < num_buffers; ++i)
1147       trace_screen_user_buffer_update(_pipe->screen, buffers[i].buffer);
1148
1149    trace_dump_call_begin("pipe_context", "set_vertex_buffers");
1150
1151    trace_dump_arg(ptr, pipe);
1152    trace_dump_arg(uint, num_buffers);
1153
1154    trace_dump_arg_begin("buffers");
1155    trace_dump_struct_array(vertex_buffer, buffers, num_buffers);
1156    trace_dump_arg_end();
1157
1158    if (num_buffers) {
1159       struct pipe_vertex_buffer *_buffers = malloc(num_buffers * sizeof(*_buffers));
1160       memcpy(_buffers, buffers, num_buffers * sizeof(*_buffers));
1161       for (i = 0; i < num_buffers; i++)
1162          _buffers[i].buffer = trace_buffer_unwrap(tr_ctx, buffers[i].buffer);
1163       pipe->set_vertex_buffers(pipe, num_buffers, _buffers);
1164       free(_buffers);
1165    } else {
1166       pipe->set_vertex_buffers(pipe, num_buffers, NULL);
1167    }
1168
1169    trace_dump_call_end();
1170 }
1171
1172
1173 static INLINE void
1174 trace_context_surface_copy(struct pipe_context *_pipe,
1175                            struct pipe_surface *dest,
1176                            unsigned destx, unsigned desty,
1177                            struct pipe_surface *src,
1178                            unsigned srcx, unsigned srcy,
1179                            unsigned width, unsigned height)
1180 {
1181    struct trace_context *tr_ctx = trace_context(_pipe);
1182    struct pipe_context *pipe = tr_ctx->pipe;
1183
1184    dest = trace_surface_unwrap(tr_ctx, dest);
1185    src = trace_surface_unwrap(tr_ctx, src);
1186
1187    trace_dump_call_begin("pipe_context", "surface_copy");
1188
1189    trace_dump_arg(ptr, pipe);
1190    trace_dump_arg(ptr, dest);
1191    trace_dump_arg(uint, destx);
1192    trace_dump_arg(uint, desty);
1193    trace_dump_arg(ptr, src);
1194    trace_dump_arg(uint, srcx);
1195    trace_dump_arg(uint, srcy);
1196    trace_dump_arg(uint, width);
1197    trace_dump_arg(uint, height);
1198
1199    pipe->surface_copy(pipe,
1200                       dest, destx, desty,
1201                       src, srcx, srcy, width, height);
1202
1203    trace_dump_call_end();
1204 }
1205
1206
1207 static INLINE void
1208 trace_context_surface_fill(struct pipe_context *_pipe,
1209                            struct pipe_surface *dst,
1210                            unsigned dstx, unsigned dsty,
1211                            unsigned width, unsigned height,
1212                            unsigned value)
1213 {
1214    struct trace_context *tr_ctx = trace_context(_pipe);
1215    struct pipe_context *pipe = tr_ctx->pipe;
1216
1217    dst = trace_surface_unwrap(tr_ctx, dst);
1218
1219    trace_dump_call_begin("pipe_context", "surface_fill");
1220
1221    trace_dump_arg(ptr, pipe);
1222    trace_dump_arg(ptr, dst);
1223    trace_dump_arg(uint, dstx);
1224    trace_dump_arg(uint, dsty);
1225    trace_dump_arg(uint, width);
1226    trace_dump_arg(uint, height);
1227
1228    pipe->surface_fill(pipe, dst, dstx, dsty, width, height, value);
1229
1230    trace_dump_call_end();
1231 }
1232
1233
1234 static INLINE void
1235 trace_context_clear(struct pipe_context *_pipe,
1236                     unsigned buffers,
1237                     const float *rgba,
1238                     double depth,
1239                     unsigned stencil)
1240 {
1241    struct trace_context *tr_ctx = trace_context(_pipe);
1242    struct pipe_context *pipe = tr_ctx->pipe;
1243
1244    trace_dump_call_begin("pipe_context", "clear");
1245
1246    trace_dump_arg(ptr, pipe);
1247    trace_dump_arg(uint, buffers);
1248    trace_dump_arg_array(float, rgba, 4);
1249    trace_dump_arg(float, depth);
1250    trace_dump_arg(uint, stencil);
1251
1252    pipe->clear(pipe, buffers, rgba, depth, stencil);
1253
1254    trace_dump_call_end();
1255 }
1256
1257
1258 static INLINE void
1259 trace_context_flush(struct pipe_context *_pipe,
1260                     unsigned flags,
1261                     struct pipe_fence_handle **fence)
1262 {
1263    struct trace_context *tr_ctx = trace_context(_pipe);
1264    struct pipe_context *pipe = tr_ctx->pipe;
1265
1266    trace_dump_call_begin("pipe_context", "flush");
1267
1268    trace_dump_arg(ptr, pipe);
1269    trace_dump_arg(uint, flags);
1270
1271    pipe->flush(pipe, flags, fence);
1272
1273    if(fence)
1274       trace_dump_ret(ptr, *fence);
1275
1276    trace_dump_call_end();
1277 }
1278
1279
1280 static INLINE void
1281 trace_context_destroy(struct pipe_context *_pipe)
1282 {
1283    struct trace_screen *tr_scr = trace_screen(_pipe->screen);
1284    struct trace_context *tr_ctx = trace_context(_pipe);
1285    struct pipe_context *pipe = tr_ctx->pipe;
1286
1287    trace_dump_call_begin("pipe_context", "destroy");
1288    trace_dump_arg(ptr, pipe);
1289    trace_dump_call_end();
1290
1291    trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
1292
1293    pipe->destroy(pipe);
1294
1295    FREE(tr_ctx);
1296 }
1297
1298 static unsigned int
1299 trace_is_texture_referenced( struct pipe_context *_pipe,
1300                             struct pipe_texture *_texture,
1301                             unsigned face, unsigned level)
1302 {
1303    struct trace_context *tr_ctx = trace_context(_pipe);
1304    struct trace_texture *tr_tex = trace_texture(_texture);
1305    struct pipe_context *pipe = tr_ctx->pipe;
1306    struct pipe_texture *texture = tr_tex->texture;
1307    unsigned int referenced;
1308
1309    trace_dump_call_begin("pipe_context", "is_texture_referenced");
1310    trace_dump_arg(ptr, pipe);
1311    trace_dump_arg(ptr, texture);
1312    trace_dump_arg(uint, face);
1313    trace_dump_arg(uint, level);
1314
1315    referenced = pipe->is_texture_referenced(pipe, texture, face, level);
1316
1317    trace_dump_ret(uint, referenced);
1318    trace_dump_call_end();
1319
1320    return referenced;
1321 }
1322
1323 static unsigned int
1324 trace_is_buffer_referenced( struct pipe_context *_pipe,
1325                             struct pipe_buffer *_buf)
1326 {
1327    struct trace_context *tr_ctx = trace_context(_pipe);
1328    struct trace_buffer *tr_buf = trace_buffer(_buf);
1329    struct pipe_context *pipe = tr_ctx->pipe;
1330    struct pipe_buffer *buf = tr_buf->buffer;
1331    unsigned int referenced;
1332
1333    trace_dump_call_begin("pipe_context", "is_buffer_referenced");
1334    trace_dump_arg(ptr, pipe);
1335    trace_dump_arg(ptr, buf);
1336
1337    referenced = pipe->is_buffer_referenced(pipe, buf);
1338
1339    trace_dump_ret(uint, referenced);
1340    trace_dump_call_end();
1341
1342    return referenced;
1343 }
1344
1345
1346 /********************************************************************
1347  * transfer
1348  */
1349
1350
1351 static struct pipe_transfer *
1352 trace_context_get_tex_transfer(struct pipe_context *_context,
1353                               struct pipe_texture *_texture,
1354                               unsigned face, unsigned level,
1355                               unsigned zslice,
1356                               enum pipe_transfer_usage usage,
1357                               unsigned x, unsigned y, unsigned w, unsigned h)
1358 {
1359    struct trace_context *tr_context = trace_context(_context);
1360    struct trace_texture *tr_tex = trace_texture(_texture);
1361    struct pipe_context *context = tr_context->pipe;
1362    struct pipe_texture *texture = tr_tex->texture;
1363    struct pipe_transfer *result = NULL;
1364
1365    assert(texture->screen == context->screen);
1366
1367    trace_dump_call_begin("pipe_context", "get_tex_transfer");
1368
1369    trace_dump_arg(ptr, context);
1370    trace_dump_arg(ptr, texture);
1371    trace_dump_arg(uint, face);
1372    trace_dump_arg(uint, level);
1373    trace_dump_arg(uint, zslice);
1374    trace_dump_arg(uint, usage);
1375
1376    trace_dump_arg(uint, x);
1377    trace_dump_arg(uint, y);
1378    trace_dump_arg(uint, w);
1379    trace_dump_arg(uint, h);
1380
1381    result = context->get_tex_transfer(context, texture, face, level, zslice, usage,
1382                                       x, y, w, h);
1383
1384    trace_dump_ret(ptr, result);
1385
1386    trace_dump_call_end();
1387
1388    if (result)
1389       result = trace_transfer_create(tr_context, tr_tex, result);
1390
1391    return result;
1392 }
1393
1394
1395 static void
1396 trace_context_tex_transfer_destroy(struct pipe_context *_context,
1397                                    struct pipe_transfer *_transfer)
1398 {
1399    struct trace_context *tr_context = trace_context(_context);
1400    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1401    struct pipe_context *context = tr_context->pipe;
1402    struct pipe_transfer *transfer = tr_trans->transfer;
1403
1404    trace_dump_call_begin("pipe_context", "tex_transfer_destroy");
1405
1406    trace_dump_arg(ptr, context);
1407    trace_dump_arg(ptr, transfer);
1408
1409    trace_dump_call_end();
1410
1411    trace_transfer_destroy(tr_context, tr_trans);
1412 }
1413
1414
1415 static void *
1416 trace_context_transfer_map(struct pipe_context *_context,
1417                           struct pipe_transfer *_transfer)
1418 {
1419    struct trace_context *tr_context = trace_context(_context);
1420    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1421    struct pipe_context *context = tr_context->pipe;
1422    struct pipe_transfer *transfer = tr_trans->transfer;
1423    void *map;
1424
1425    map = context->transfer_map(context, transfer);
1426    if(map) {
1427       if(transfer->usage & PIPE_TRANSFER_WRITE) {
1428          assert(!tr_trans->map);
1429          tr_trans->map = map;
1430       }
1431    }
1432
1433    return map;
1434 }
1435
1436
1437 static void
1438 trace_context_transfer_unmap(struct pipe_context *_context,
1439                              struct pipe_transfer *_transfer)
1440 {
1441    struct trace_context *tr_ctx = trace_context(_context);
1442    struct trace_transfer *tr_trans = trace_transfer(_transfer);
1443    struct pipe_context *context = tr_ctx->pipe;
1444    struct pipe_transfer *transfer = tr_trans->transfer;
1445
1446    if(tr_trans->map) {
1447       size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
1448
1449       trace_dump_call_begin("pipe_context", "transfer_write");
1450
1451       trace_dump_arg(ptr, context);
1452
1453       trace_dump_arg(ptr, transfer);
1454
1455       trace_dump_arg_begin("stride");
1456       trace_dump_uint(transfer->stride);
1457       trace_dump_arg_end();
1458
1459       trace_dump_arg_begin("data");
1460       trace_dump_bytes(tr_trans->map, size);
1461       trace_dump_arg_end();
1462
1463       trace_dump_arg_begin("size");
1464       trace_dump_uint(size);
1465       trace_dump_arg_end();
1466
1467       trace_dump_call_end();
1468
1469       tr_trans->map = NULL;
1470    }
1471
1472    context->transfer_unmap(context, transfer);
1473 }
1474
1475 static const struct debug_named_value rbug_blocker_flags[] = {
1476    {"before", 1},
1477    {"after", 2},
1478    {NULL, 0},
1479 };
1480
1481 struct pipe_context *
1482 trace_context_create(struct trace_screen *tr_scr,
1483                      struct pipe_context *pipe)
1484 {
1485    struct trace_context *tr_ctx;
1486
1487    if(!pipe)
1488       goto error1;
1489
1490    if(!trace_enabled())
1491       goto error1;
1492
1493    tr_ctx = CALLOC_STRUCT(trace_context);
1494    if(!tr_ctx)
1495       goto error1;
1496
1497    tr_ctx->base.winsys = NULL;
1498    tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
1499    tr_ctx->base.screen = &tr_scr->base;
1500    tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
1501                                                  rbug_blocker_flags,
1502                                                  0);
1503    pipe_mutex_init(tr_ctx->draw_mutex);
1504    pipe_condvar_init(tr_ctx->draw_cond);
1505    pipe_mutex_init(tr_ctx->list_mutex);
1506    make_empty_list(&tr_ctx->shaders);
1507
1508    tr_ctx->base.destroy = trace_context_destroy;
1509    tr_ctx->base.draw_arrays = trace_context_draw_arrays;
1510    tr_ctx->base.draw_elements = trace_context_draw_elements;
1511    tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
1512    tr_ctx->base.create_query = trace_context_create_query;
1513    tr_ctx->base.destroy_query = trace_context_destroy_query;
1514    tr_ctx->base.begin_query = trace_context_begin_query;
1515    tr_ctx->base.end_query = trace_context_end_query;
1516    tr_ctx->base.get_query_result = trace_context_get_query_result;
1517    tr_ctx->base.create_blend_state = trace_context_create_blend_state;
1518    tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
1519    tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
1520    tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
1521    tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
1522    tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
1523    tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
1524    tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
1525    tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
1526    tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
1527    tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
1528    tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
1529    tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
1530    tr_ctx->base.create_fs_state = trace_context_create_fs_state;
1531    tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
1532    tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
1533    tr_ctx->base.create_vs_state = trace_context_create_vs_state;
1534    tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
1535    tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
1536    tr_ctx->base.create_vertex_elements_state = trace_context_create_vertex_elements_state;
1537    tr_ctx->base.bind_vertex_elements_state = trace_context_bind_vertex_elements_state;
1538    tr_ctx->base.delete_vertex_elements_state = trace_context_delete_vertex_elements_state;
1539    tr_ctx->base.set_blend_color = trace_context_set_blend_color;
1540    tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
1541    tr_ctx->base.set_clip_state = trace_context_set_clip_state;
1542    tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
1543    tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
1544    tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
1545    tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
1546    tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
1547    tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
1548    tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
1549    tr_ctx->base.create_sampler_view = trace_create_sampler_view;
1550    tr_ctx->base.sampler_view_destroy = trace_sampler_view_destroy;
1551    tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
1552    if (pipe->surface_copy)
1553       tr_ctx->base.surface_copy = trace_context_surface_copy;
1554    if (pipe->surface_fill)
1555       tr_ctx->base.surface_fill = trace_context_surface_fill;
1556    tr_ctx->base.clear = trace_context_clear;
1557    tr_ctx->base.flush = trace_context_flush;
1558    tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
1559    tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
1560
1561    tr_ctx->base.get_tex_transfer = trace_context_get_tex_transfer;
1562    tr_ctx->base.tex_transfer_destroy = trace_context_tex_transfer_destroy;
1563    tr_ctx->base.transfer_map = trace_context_transfer_map;
1564    tr_ctx->base.transfer_unmap = trace_context_transfer_unmap;
1565
1566    tr_ctx->pipe = pipe;
1567
1568    trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
1569
1570    return &tr_ctx->base;
1571
1572 error1:
1573    return pipe;
1574 }