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