src/gallium/drivers/trace/tr_context.c

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