src/gallium/drivers/trace/tr_screen.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_format.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_simple_list.h"
  31
  32 #include "tr_buffer.h"
  33 #include "tr_dump.h"
  34 #include "tr_dump_state.h"
  35 #include "tr_texture.h"
  36 #include "tr_screen.h"
  37
  38 #include "pipe/p_inlines.h"
  39 #include "pipe/p_format.h"
  40
  41
  42 static boolean trace = FALSE;
  43 static boolean rbug = FALSE;
  44
  45 static const char *
  46 trace_screen_get_name(struct pipe_screen *_screen)
  47 {
  48    struct trace_screen *tr_scr = trace_screen(_screen);
  49    struct pipe_screen *screen = tr_scr->screen;
  50    const char *result;
  51
  52    trace_dump_call_begin("pipe_screen", "get_name");
  53
  54    trace_dump_arg(ptr, screen);
  55
  56    result = screen->get_name(screen);
  57
  58    trace_dump_ret(string, result);
  59
  60    trace_dump_call_end();
  61
  62    return result;
  63 }
  64
  65
  66 static const char *
  67 trace_screen_get_vendor(struct pipe_screen *_screen)
  68 {
  69    struct trace_screen *tr_scr = trace_screen(_screen);
  70    struct pipe_screen *screen = tr_scr->screen;
  71    const char *result;
  72
  73    trace_dump_call_begin("pipe_screen", "get_vendor");
  74
  75    trace_dump_arg(ptr, screen);
  76
  77    result = screen->get_vendor(screen);
  78
  79    trace_dump_ret(string, result);
  80
  81    trace_dump_call_end();
  82
  83    return result;
  84 }
  85
  86
  87 static int
  88 trace_screen_get_param(struct pipe_screen *_screen,
  89                        int param)
  90 {
  91    struct trace_screen *tr_scr = trace_screen(_screen);
  92    struct pipe_screen *screen = tr_scr->screen;
  93    int result;
  94
  95    trace_dump_call_begin("pipe_screen", "get_param");
  96
  97    trace_dump_arg(ptr, screen);
  98    trace_dump_arg(int, param);
  99
 100    result = screen->get_param(screen, param);
 101
 102    trace_dump_ret(int, result);
 103
 104    trace_dump_call_end();
 105
 106    return result;
 107 }
 108
 109
 110 static float
 111 trace_screen_get_paramf(struct pipe_screen *_screen,
 112                         int param)
 113 {
 114    struct trace_screen *tr_scr = trace_screen(_screen);
 115    struct pipe_screen *screen = tr_scr->screen;
 116    float result;
 117
 118    trace_dump_call_begin("pipe_screen", "get_paramf");
 119
 120    trace_dump_arg(ptr, screen);
 121    trace_dump_arg(int, param);
 122
 123    result = screen->get_paramf(screen, param);
 124
 125    trace_dump_ret(float, result);
 126
 127    trace_dump_call_end();
 128
 129    return result;
 130 }
 131
 132
 133 static boolean
 134 trace_screen_is_format_supported(struct pipe_screen *_screen,
 135                                  enum pipe_format format,
 136                                  enum pipe_texture_target target,
 137                                  unsigned tex_usage,
 138                                  unsigned geom_flags)
 139 {
 140    struct trace_screen *tr_scr = trace_screen(_screen);
 141    struct pipe_screen *screen = tr_scr->screen;
 142    boolean result;
 143
 144    trace_dump_call_begin("pipe_screen", "is_format_supported");
 145
 146    trace_dump_arg(ptr, screen);
 147    trace_dump_arg(format, format);
 148    trace_dump_arg(int, target);
 149    trace_dump_arg(uint, tex_usage);
 150    trace_dump_arg(uint, geom_flags);
 151
 152    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
 153
 154    trace_dump_ret(bool, result);
 155
 156    trace_dump_call_end();
 157
 158    return result;
 159 }
 160
 161
 162 static void
 163 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
 164                                struct pipe_surface *_surface,
 165                                void *context_private)
 166 {
 167    struct trace_screen *tr_scr = trace_screen(_screen);
 168    struct trace_surface *tr_surf = trace_surface(_surface);
 169    struct pipe_screen *screen = tr_scr->screen;
 170    struct pipe_surface *surface = tr_surf->surface;
 171
 172    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
 173
 174    trace_dump_arg(ptr, screen);
 175    trace_dump_arg(ptr, surface);
 176    /* XXX: hide, as there is nothing we can do with this
 177    trace_dump_arg(ptr, context_private);
 178    */
 179
 180    screen->flush_frontbuffer(screen, surface, context_private);
 181
 182    trace_dump_call_end();
 183 }
 184
 185
 186 /********************************************************************
 187  * texture
 188  */
 189
 190
 191 static struct pipe_texture *
 192 trace_screen_texture_create(struct pipe_screen *_screen,
 193                             const struct pipe_texture *templat)
 194 {
 195    struct trace_screen *tr_scr = trace_screen(_screen);
 196    struct pipe_screen *screen = tr_scr->screen;
 197    struct pipe_texture *result;
 198
 199    trace_dump_call_begin("pipe_screen", "texture_create");
 200
 201    trace_dump_arg(ptr, screen);
 202    trace_dump_arg(template, templat);
 203
 204    result = screen->texture_create(screen, templat);
 205
 206    trace_dump_ret(ptr, result);
 207
 208    trace_dump_call_end();
 209
 210    result = trace_texture_create(tr_scr, result);
 211
 212    return result;
 213 }
 214
 215
 216 static struct pipe_texture *
 217 trace_screen_texture_blanket(struct pipe_screen *_screen,
 218                              const struct pipe_texture *templat,
 219                              const unsigned *ppitch,
 220                              struct pipe_buffer *_buffer)
 221 {
 222    struct trace_screen *tr_scr = trace_screen(_screen);
 223    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 224    struct pipe_screen *screen = tr_scr->screen;
 225    struct pipe_buffer *buffer = tr_buf->buffer;
 226    unsigned pitch = *ppitch;
 227    struct pipe_texture *result;
 228
 229    trace_dump_call_begin("pipe_screen", "texture_blanket");
 230
 231    trace_dump_arg(ptr, screen);
 232    trace_dump_arg(template, templat);
 233    trace_dump_arg(uint, pitch);
 234    trace_dump_arg(ptr, buffer);
 235
 236    result = screen->texture_blanket(screen, templat, ppitch, buffer);
 237
 238    trace_dump_ret(ptr, result);
 239
 240    trace_dump_call_end();
 241
 242    result = trace_texture_create(tr_scr, result);
 243
 244    return result;
 245 }
 246
 247
 248 static void
 249 trace_screen_texture_destroy(struct pipe_texture *_texture)
 250 {
 251    struct trace_screen *tr_scr = trace_screen(_texture->screen);
 252    struct trace_texture *tr_tex = trace_texture(_texture);
 253    struct pipe_screen *screen = tr_scr->screen;
 254    struct pipe_texture *texture = tr_tex->texture;
 255
 256    assert(texture->screen == screen);
 257
 258    trace_dump_call_begin("pipe_screen", "texture_destroy");
 259
 260    trace_dump_arg(ptr, screen);
 261    trace_dump_arg(ptr, texture);
 262
 263    trace_dump_call_end();
 264
 265    trace_texture_destroy(tr_tex);
 266 }
 267
 268
 269 /********************************************************************
 270  * surface
 271  */
 272
 273
 274 static struct pipe_surface *
 275 trace_screen_get_tex_surface(struct pipe_screen *_screen,
 276                              struct pipe_texture *_texture,
 277                              unsigned face, unsigned level,
 278                              unsigned zslice,
 279                              unsigned usage)
 280 {
 281    struct trace_screen *tr_scr = trace_screen(_screen);
 282    struct trace_texture *tr_tex = trace_texture(_texture);
 283    struct pipe_screen *screen = tr_scr->screen;
 284    struct pipe_texture *texture = tr_tex->texture;
 285    struct pipe_surface *result = NULL;
 286
 287    assert(texture->screen == screen);
 288
 289    trace_dump_call_begin("pipe_screen", "get_tex_surface");
 290
 291    trace_dump_arg(ptr, screen);
 292    trace_dump_arg(ptr, texture);
 293    trace_dump_arg(uint, face);
 294    trace_dump_arg(uint, level);
 295    trace_dump_arg(uint, zslice);
 296    trace_dump_arg(uint, usage);
 297
 298    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 299
 300    trace_dump_ret(ptr, result);
 301
 302    trace_dump_call_end();
 303
 304    result = trace_surface_create(tr_tex, result);
 305
 306    return result;
 307 }
 308
 309
 310 static void
 311 trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
 312 {
 313    struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
 314    struct trace_surface *tr_surf = trace_surface(_surface);
 315    struct pipe_screen *screen = tr_scr->screen;
 316    struct pipe_surface *surface = tr_surf->surface;
 317
 318    trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
 319
 320    trace_dump_arg(ptr, screen);
 321    trace_dump_arg(ptr, surface);
 322
 323    trace_dump_call_end();
 324
 325    trace_surface_destroy(tr_surf);
 326 }
 327
 328
 329 /********************************************************************
 330  * transfer
 331  */
 332
 333
 334 static struct pipe_transfer *
 335 trace_screen_get_tex_transfer(struct pipe_screen *_screen,
 336                               struct pipe_texture *_texture,
 337                               unsigned face, unsigned level,
 338                               unsigned zslice,
 339                               enum pipe_transfer_usage usage,
 340                               unsigned x, unsigned y, unsigned w, unsigned h)
 341 {
 342    struct trace_screen *tr_scr = trace_screen(_screen);
 343    struct trace_texture *tr_tex = trace_texture(_texture);
 344    struct pipe_screen *screen = tr_scr->screen;
 345    struct pipe_texture *texture = tr_tex->texture;
 346    struct pipe_transfer *result = NULL;
 347
 348    assert(texture->screen == screen);
 349
 350    trace_dump_call_begin("pipe_screen", "get_tex_transfer");
 351
 352    trace_dump_arg(ptr, screen);
 353    trace_dump_arg(ptr, texture);
 354    trace_dump_arg(uint, face);
 355    trace_dump_arg(uint, level);
 356    trace_dump_arg(uint, zslice);
 357    trace_dump_arg(uint, usage);
 358
 359    trace_dump_arg(uint, x);
 360    trace_dump_arg(uint, y);
 361    trace_dump_arg(uint, w);
 362    trace_dump_arg(uint, h);
 363
 364    result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
 365                                      x, y, w, h);
 366
 367    trace_dump_ret(ptr, result);
 368
 369    trace_dump_call_end();
 370
 371    if (result)
 372       result = trace_transfer_create(tr_tex, result);
 373
 374    return result;
 375 }
 376
 377
 378 static void
 379 trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 380 {
 381    struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
 382    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 383    struct pipe_screen *screen = tr_scr->screen;
 384    struct pipe_transfer *transfer = tr_trans->transfer;
 385
 386    trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
 387
 388    trace_dump_arg(ptr, screen);
 389    trace_dump_arg(ptr, transfer);
 390
 391    trace_dump_call_end();
 392
 393    trace_transfer_destroy(tr_trans);
 394 }
 395
 396
 397 static void *
 398 trace_screen_transfer_map(struct pipe_screen *_screen,
 399                           struct pipe_transfer *_transfer)
 400 {
 401    struct trace_screen *tr_scr = trace_screen(_screen);
 402    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 403    struct pipe_screen *screen = tr_scr->screen;
 404    struct pipe_transfer *transfer = tr_trans->transfer;
 405    void *map;
 406
 407    map = screen->transfer_map(screen, transfer);
 408    if(map) {
 409       if(transfer->usage & PIPE_TRANSFER_WRITE) {
 410          assert(!tr_trans->map);
 411          tr_trans->map = map;
 412       }
 413    }
 414
 415    return map;
 416 }
 417
 418
 419 static void
 420 trace_screen_transfer_unmap(struct pipe_screen *_screen,
 421                            struct pipe_transfer *_transfer)
 422 {
 423    struct trace_screen *tr_scr = trace_screen(_screen);
 424    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 425    struct pipe_screen *screen = tr_scr->screen;
 426    struct pipe_transfer *transfer = tr_trans->transfer;
 427
 428    if(tr_trans->map) {
 429       size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
 430
 431       trace_dump_call_begin("pipe_screen", "transfer_write");
 432
 433       trace_dump_arg(ptr, screen);
 434
 435       trace_dump_arg(ptr, transfer);
 436
 437       trace_dump_arg_begin("stride");
 438       trace_dump_uint(transfer->stride);
 439       trace_dump_arg_end();
 440
 441       trace_dump_arg_begin("data");
 442       trace_dump_bytes(tr_trans->map, size);
 443       trace_dump_arg_end();
 444
 445       trace_dump_arg_begin("size");
 446       trace_dump_uint(size);
 447       trace_dump_arg_end();
 448
 449       trace_dump_call_end();
 450
 451       tr_trans->map = NULL;
 452    }
 453
 454    screen->transfer_unmap(screen, transfer);
 455 }
 456
 457
 458 /********************************************************************
 459  * buffer
 460  */
 461
 462
 463 static struct pipe_buffer *
 464 trace_screen_surface_buffer_create(struct pipe_screen *_screen,
 465                                    unsigned width, unsigned height,
 466                                    enum pipe_format format,
 467                                    unsigned usage,
 468                                    unsigned tex_usage,
 469                                    unsigned *pstride)
 470 {
 471    struct trace_screen *tr_scr = trace_screen(_screen);
 472    struct pipe_screen *screen = tr_scr->screen;
 473    unsigned stride;
 474    struct pipe_buffer *result;
 475
 476    trace_dump_call_begin("pipe_screen", "surface_buffer_create");
 477
 478    trace_dump_arg(ptr, screen);
 479    trace_dump_arg(uint, width);
 480    trace_dump_arg(uint, height);
 481    trace_dump_arg(format, format);
 482    trace_dump_arg(uint, usage);
 483    trace_dump_arg(uint, tex_usage);
 484
 485    result = screen->surface_buffer_create(screen,
 486                                           width, height,
 487                                           format,
 488                                           usage,
 489                                           tex_usage,
 490                                           pstride);
 491
 492    stride = *pstride;
 493
 494    trace_dump_arg(uint, stride);
 495
 496    trace_dump_ret(ptr, result);
 497
 498    trace_dump_call_end();
 499
 500    return trace_buffer_create(tr_scr, result);
 501 }
 502
 503
 504 static struct pipe_buffer *
 505 trace_screen_buffer_create(struct pipe_screen *_screen,
 506                            unsigned alignment,
 507                            unsigned usage,
 508                            unsigned size)
 509 {
 510    struct trace_screen *tr_scr = trace_screen(_screen);
 511    struct pipe_screen *screen = tr_scr->screen;
 512    struct pipe_buffer *result;
 513
 514    trace_dump_call_begin("pipe_screen", "buffer_create");
 515
 516    trace_dump_arg(ptr, screen);
 517    trace_dump_arg(uint, alignment);
 518    trace_dump_arg(uint, usage);
 519    trace_dump_arg(uint, size);
 520
 521    result = screen->buffer_create(screen, alignment, usage, size);
 522
 523    trace_dump_ret(ptr, result);
 524
 525    trace_dump_call_end();
 526
 527    /* Zero the buffer to avoid dumping uninitialized memory */
 528    if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 529       void *map;
 530       map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
 531       if(map) {
 532          memset(map, 0, result->size);
 533          screen->buffer_unmap(screen, result);
 534       }
 535    }
 536
 537    return trace_buffer_create(tr_scr, result);
 538 }
 539
 540
 541 static struct pipe_buffer *
 542 trace_screen_user_buffer_create(struct pipe_screen *_screen,
 543                                 void *data,
 544                                 unsigned size)
 545 {
 546    struct trace_screen *tr_scr = trace_screen(_screen);
 547    struct pipe_screen *screen = tr_scr->screen;
 548    struct pipe_buffer *result;
 549
 550    trace_dump_call_begin("pipe_screen", "user_buffer_create");
 551
 552    trace_dump_arg(ptr, screen);
 553    trace_dump_arg_begin("data");
 554    trace_dump_bytes(data, size);
 555    trace_dump_arg_end();
 556    trace_dump_arg(uint, size);
 557
 558    result = screen->user_buffer_create(screen, data, size);
 559
 560    trace_dump_ret(ptr, result);
 561
 562    trace_dump_call_end();
 563
 564    if(result) {
 565       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 566       result->usage |= TRACE_BUFFER_USAGE_USER;
 567    }
 568
 569    return trace_buffer_create(tr_scr, result);
 570 }
 571
 572
 573 /**
 574  * This function is used to track if data has been changed on a user buffer
 575  * without map/unmap being called.
 576  */
 577 void
 578 trace_screen_user_buffer_update(struct pipe_screen *_screen,
 579                                 struct pipe_buffer *_buffer)
 580 {
 581 #if 0
 582    struct trace_screen *tr_scr = trace_screen(_screen);
 583    struct pipe_screen *screen = tr_scr->screen;
 584    const void *map;
 585
 586    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 587       map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 588       if(map) {
 589          trace_dump_call_begin("pipe_winsys", "buffer_write");
 590
 591          trace_dump_arg(ptr, screen);
 592
 593          trace_dump_arg(ptr, buffer);
 594
 595          trace_dump_arg_begin("data");
 596          trace_dump_bytes(map, buffer->size);
 597          trace_dump_arg_end();
 598
 599          trace_dump_arg_begin("size");
 600          trace_dump_uint(buffer->size);
 601          trace_dump_arg_end();
 602
 603          trace_dump_call_end();
 604
 605          screen->buffer_unmap(screen, buffer);
 606       }
 607    }
 608 #endif
 609 }
 610
 611
 612 static void *
 613 trace_screen_buffer_map(struct pipe_screen *_screen,
 614                         struct pipe_buffer *_buffer,
 615                         unsigned usage)
 616 {
 617    struct trace_screen *tr_scr = trace_screen(_screen);
 618    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 619    struct pipe_screen *screen = tr_scr->screen;
 620    struct pipe_buffer *buffer = tr_buf->buffer;
 621    void *map;
 622
 623    assert(screen->buffer_map);
 624    map = screen->buffer_map(screen, buffer, usage);
 625    if(map) {
 626       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 627          tr_buf->map = map;
 628       }
 629    }
 630
 631    return map;
 632 }
 633
 634
 635 static void *
 636 trace_screen_buffer_map_range(struct pipe_screen *_screen,
 637                               struct pipe_buffer *_buffer,
 638                               unsigned offset,
 639                               unsigned length,
 640                               unsigned usage)
 641 {
 642    struct trace_screen *tr_scr = trace_screen(_screen);
 643    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 644    struct pipe_screen *screen = tr_scr->screen;
 645    struct pipe_buffer *buffer = tr_buf->buffer;
 646    void *map;
 647
 648    assert(screen->buffer_map_range);
 649    map = screen->buffer_map_range(screen, buffer, offset, length, usage);
 650    if(map) {
 651       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 652          tr_buf->map = map;
 653       }
 654    }
 655
 656    return map;
 657 }
 658
 659
 660 static void
 661 buffer_write(struct pipe_screen *screen,
 662              struct pipe_buffer *buffer,
 663              unsigned offset,
 664              const char *map,
 665              unsigned size)
 666 {
 667    assert(map);
 668
 669    trace_dump_call_begin("pipe_screen", "buffer_write");
 670
 671    trace_dump_arg(ptr, screen);
 672
 673    trace_dump_arg(ptr, buffer);
 674
 675    trace_dump_arg(uint, offset);
 676
 677    trace_dump_arg_begin("data");
 678    trace_dump_bytes(map + offset, size);
 679    trace_dump_arg_end();
 680
 681    trace_dump_arg(uint, size);
 682
 683    trace_dump_call_end();
 684
 685 }
 686
 687
 688 static void
 689 trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 690                                        struct pipe_buffer *_buffer,
 691                                        unsigned offset,
 692                                        unsigned length)
 693 {
 694    struct trace_screen *tr_scr = trace_screen(_screen);
 695    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 696    struct pipe_screen *screen = tr_scr->screen;
 697    struct pipe_buffer *buffer = tr_buf->buffer;
 698
 699    assert(tr_buf->map);
 700    buffer_write(screen, buffer, offset, tr_buf->map, length);
 701    tr_buf->range_flushed = TRUE;
 702    screen->buffer_flush_mapped_range(screen, buffer, offset, length);
 703 }
 704
 705
 706 static void
 707 trace_screen_buffer_unmap(struct pipe_screen *_screen,
 708                           struct pipe_buffer *_buffer)
 709 {
 710    struct trace_screen *tr_scr = trace_screen(_screen);
 711    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 712    struct pipe_screen *screen = tr_scr->screen;
 713    struct pipe_buffer *buffer = tr_buf->buffer;
 714
 715    if (tr_buf->map && !tr_buf->range_flushed)
 716       buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
 717    tr_buf->map = NULL;
 718    tr_buf->range_flushed = FALSE;
 719    screen->buffer_unmap(screen, buffer);
 720 }
 721
 722
 723 static void
 724 trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
 725 {
 726    struct trace_screen *tr_scr = trace_screen(_buffer->screen);
 727    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 728    struct pipe_screen *screen = tr_scr->screen;
 729    struct pipe_buffer *buffer = tr_buf->buffer;
 730
 731    trace_dump_call_begin("pipe_screen", "buffer_destroy");
 732
 733    trace_dump_arg(ptr, screen);
 734    trace_dump_arg(ptr, buffer);
 735
 736    trace_dump_call_end();
 737
 738    trace_buffer_destroy(tr_scr, _buffer);
 739 }
 740
 741
 742 /********************************************************************
 743  * fence
 744  */
 745
 746
 747 static void
 748 trace_screen_fence_reference(struct pipe_screen *_screen,
 749                              struct pipe_fence_handle **pdst,
 750                              struct pipe_fence_handle *src)
 751 {
 752    struct trace_screen *tr_scr = trace_screen(_screen);
 753    struct pipe_screen *screen = tr_scr->screen;
 754    struct pipe_fence_handle *dst;
 755
 756    assert(pdst);
 757    dst = *pdst;
 758
 759    trace_dump_call_begin("pipe_screen", "fence_reference");
 760
 761    trace_dump_arg(ptr, screen);
 762    trace_dump_arg(ptr, dst);
 763    trace_dump_arg(ptr, src);
 764
 765    screen->fence_reference(screen, pdst, src);
 766
 767    trace_dump_call_end();
 768 }
 769
 770
 771 static int
 772 trace_screen_fence_signalled(struct pipe_screen *_screen,
 773                              struct pipe_fence_handle *fence,
 774                              unsigned flags)
 775 {
 776    struct trace_screen *tr_scr = trace_screen(_screen);
 777    struct pipe_screen *screen = tr_scr->screen;
 778    int result;
 779
 780    trace_dump_call_begin("pipe_screen", "fence_signalled");
 781
 782    trace_dump_arg(ptr, screen);
 783    trace_dump_arg(ptr, fence);
 784    trace_dump_arg(uint, flags);
 785
 786    result = screen->fence_signalled(screen, fence, flags);
 787
 788    trace_dump_ret(int, result);
 789
 790    trace_dump_call_end();
 791
 792    return result;
 793 }
 794
 795
 796 static int
 797 trace_screen_fence_finish(struct pipe_screen *_screen,
 798                           struct pipe_fence_handle *fence,
 799                           unsigned flags)
 800 {
 801    struct trace_screen *tr_scr = trace_screen(_screen);
 802    struct pipe_screen *screen = tr_scr->screen;
 803    int result;
 804
 805    trace_dump_call_begin("pipe_screen", "fence_finish");
 806
 807    trace_dump_arg(ptr, screen);
 808    trace_dump_arg(ptr, fence);
 809    trace_dump_arg(uint, flags);
 810
 811    result = screen->fence_finish(screen, fence, flags);
 812
 813    trace_dump_ret(int, result);
 814
 815    trace_dump_call_end();
 816
 817    return result;
 818 }
 819
 820
 821 /********************************************************************
 822  * screen
 823  */
 824
 825 static void
 826 trace_screen_destroy(struct pipe_screen *_screen)
 827 {
 828    struct trace_screen *tr_scr = trace_screen(_screen);
 829    struct pipe_screen *screen = tr_scr->screen;
 830
 831    trace_dump_call_begin("pipe_screen", "destroy");
 832    trace_dump_arg(ptr, screen);
 833    trace_dump_call_end();
 834    trace_dump_trace_end();
 835
 836    if (tr_scr->rbug)
 837       trace_rbug_stop(tr_scr->rbug);
 838
 839    screen->destroy(screen);
 840
 841    FREE(tr_scr);
 842 }
 843
 844 boolean
 845 trace_enabled(void)
 846 {
 847    static boolean firstrun = TRUE;
 848
 849    if (!firstrun)
 850       return trace;
 851    firstrun = FALSE;
 852
 853    trace_dump_init();
 854
 855    if(trace_dump_trace_begin()) {
 856       trace_dumping_start();
 857       trace = TRUE;
 858    }
 859
 860    if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
 861       trace = TRUE;
 862       rbug = TRUE;
 863    }
 864
 865    return trace;
 866 }
 867
 868 struct pipe_screen *
 869 trace_screen_create(struct pipe_screen *screen)
 870 {
 871    struct trace_screen *tr_scr;
 872    struct pipe_winsys *winsys;
 873
 874    if(!screen)
 875       goto error1;
 876
 877    if (!trace_enabled())
 878       goto error1;
 879
 880    trace_dump_call_begin("", "pipe_screen_create");
 881
 882    tr_scr = CALLOC_STRUCT(trace_screen);
 883    if(!tr_scr)
 884       goto error2;
 885
 886 #if 0
 887    winsys = trace_winsys_create(screen->winsys);
 888    if(!winsys)
 889       goto error3;
 890 #else
 891    winsys = screen->winsys;
 892 #endif
 893    pipe_mutex_init(tr_scr->list_mutex);
 894    make_empty_list(&tr_scr->buffers);
 895    make_empty_list(&tr_scr->contexts);
 896    make_empty_list(&tr_scr->textures);
 897    make_empty_list(&tr_scr->surfaces);
 898    make_empty_list(&tr_scr->transfers);
 899
 900    tr_scr->base.winsys = winsys;
 901    tr_scr->base.destroy = trace_screen_destroy;
 902    tr_scr->base.get_name = trace_screen_get_name;
 903    tr_scr->base.get_vendor = trace_screen_get_vendor;
 904    tr_scr->base.get_param = trace_screen_get_param;
 905    tr_scr->base.get_paramf = trace_screen_get_paramf;
 906    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 907    tr_scr->base.texture_create = trace_screen_texture_create;
 908    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
 909    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 910    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 911    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 912    tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
 913    tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
 914    tr_scr->base.transfer_map = trace_screen_transfer_map;
 915    tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
 916    tr_scr->base.buffer_create = trace_screen_buffer_create;
 917    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 918    tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
 919    if (screen->buffer_map)
 920       tr_scr->base.buffer_map = trace_screen_buffer_map;
 921    if (screen->buffer_map_range)
 922       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 923    if (screen->buffer_flush_mapped_range)
 924       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 925    if (screen->buffer_unmap)
 926       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 927    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 928    tr_scr->base.fence_reference = trace_screen_fence_reference;
 929    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 930    tr_scr->base.fence_finish = trace_screen_fence_finish;
 931    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 932    tr_scr->screen = screen;
 933
 934    trace_dump_ret(ptr, screen);
 935    trace_dump_call_end();
 936
 937    if (rbug)
 938       tr_scr->rbug = trace_rbug_start(tr_scr);
 939
 940    return &tr_scr->base;
 941
 942 #if 0
 943 error3:
 944    FREE(tr_scr);
 945 #endif
 946 error2:
 947    trace_dump_ret(ptr, screen);
 948    trace_dump_call_end();
 949    trace_dump_trace_end();
 950 error1:
 951    return screen;
 952 }
 953
 954
 955 struct trace_screen *
 956 trace_screen(struct pipe_screen *screen)
 957 {
 958    assert(screen);
 959    assert(screen->destroy == trace_screen_destroy);
 960    return (struct trace_screen *)screen;
 961 }