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