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