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