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    result = trace_transfer_create(tr_tex, result);
 370
 371    return result;
 372 }
 373
 374
 375 static void
 376 trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 377 {
 378    struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
 379    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 380    struct pipe_screen *screen = tr_scr->screen;
 381    struct pipe_transfer *transfer = tr_trans->transfer;
 382
 383    trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
 384
 385    trace_dump_arg(ptr, screen);
 386    trace_dump_arg(ptr, transfer);
 387
 388    trace_dump_call_end();
 389
 390    trace_transfer_destroy(tr_trans);
 391 }
 392
 393
 394 static void *
 395 trace_screen_transfer_map(struct pipe_screen *_screen,
 396                           struct pipe_transfer *_transfer)
 397 {
 398    struct trace_screen *tr_scr = trace_screen(_screen);
 399    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 400    struct pipe_screen *screen = tr_scr->screen;
 401    struct pipe_transfer *transfer = tr_trans->transfer;
 402    void *map;
 403
 404    map = screen->transfer_map(screen, transfer);
 405    if(map) {
 406       if(transfer->usage != PIPE_TRANSFER_READ) {
 407          assert(!tr_trans->map);
 408          tr_trans->map = map;
 409       }
 410    }
 411
 412    return map;
 413 }
 414
 415
 416 static void
 417 trace_screen_transfer_unmap(struct pipe_screen *_screen,
 418                            struct pipe_transfer *_transfer)
 419 {
 420    struct trace_screen *tr_scr = trace_screen(_screen);
 421    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 422    struct pipe_screen *screen = tr_scr->screen;
 423    struct pipe_transfer *transfer = tr_trans->transfer;
 424
 425    if(tr_trans->map) {
 426       size_t size = transfer->nblocksy * transfer->stride;
 427
 428       trace_dump_call_begin("pipe_screen", "transfer_write");
 429
 430       trace_dump_arg(ptr, screen);
 431
 432       trace_dump_arg(ptr, transfer);
 433
 434       trace_dump_arg_begin("stride");
 435       trace_dump_uint(transfer->stride);
 436       trace_dump_arg_end();
 437
 438       trace_dump_arg_begin("data");
 439       trace_dump_bytes(tr_trans->map, size);
 440       trace_dump_arg_end();
 441
 442       trace_dump_arg_begin("size");
 443       trace_dump_uint(size);
 444       trace_dump_arg_end();
 445
 446       trace_dump_call_end();
 447
 448       tr_trans->map = NULL;
 449    }
 450
 451    screen->transfer_unmap(screen, transfer);
 452 }
 453
 454
 455 /********************************************************************
 456  * buffer
 457  */
 458
 459
 460 static struct pipe_buffer *
 461 trace_screen_surface_buffer_create(struct pipe_screen *_screen,
 462                                    unsigned width, unsigned height,
 463                                    enum pipe_format format,
 464                                    unsigned usage,
 465                                    unsigned tex_usage,
 466                                    unsigned *pstride)
 467 {
 468    struct trace_screen *tr_scr = trace_screen(_screen);
 469    struct pipe_screen *screen = tr_scr->screen;
 470    unsigned stride;
 471    struct pipe_buffer *result;
 472
 473    trace_dump_call_begin("pipe_screen", "surface_buffer_create");
 474
 475    trace_dump_arg(ptr, screen);
 476    trace_dump_arg(uint, width);
 477    trace_dump_arg(uint, height);
 478    trace_dump_arg(format, format);
 479    trace_dump_arg(uint, usage);
 480    trace_dump_arg(uint, tex_usage);
 481
 482    result = screen->surface_buffer_create(screen,
 483                                           width, height,
 484                                           format,
 485                                           usage,
 486                                           tex_usage,
 487                                           pstride);
 488
 489    stride = *pstride;
 490
 491    trace_dump_arg(uint, stride);
 492
 493    trace_dump_ret(ptr, result);
 494
 495    trace_dump_call_end();
 496
 497    return trace_buffer_create(tr_scr, result);
 498 }
 499
 500
 501 static struct pipe_buffer *
 502 trace_screen_buffer_create(struct pipe_screen *_screen,
 503                            unsigned alignment,
 504                            unsigned usage,
 505                            unsigned size)
 506 {
 507    struct trace_screen *tr_scr = trace_screen(_screen);
 508    struct pipe_screen *screen = tr_scr->screen;
 509    struct pipe_buffer *result;
 510
 511    trace_dump_call_begin("pipe_screen", "buffer_create");
 512
 513    trace_dump_arg(ptr, screen);
 514    trace_dump_arg(uint, alignment);
 515    trace_dump_arg(uint, usage);
 516    trace_dump_arg(uint, size);
 517
 518    result = screen->buffer_create(screen, alignment, usage, size);
 519
 520    trace_dump_ret(ptr, result);
 521
 522    trace_dump_call_end();
 523
 524    /* Zero the buffer to avoid dumping uninitialized memory */
 525    if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 526       void *map;
 527       map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
 528       if(map) {
 529          memset(map, 0, result->size);
 530          screen->buffer_unmap(screen, result);
 531       }
 532    }
 533
 534    return trace_buffer_create(tr_scr, result);
 535 }
 536
 537
 538 static struct pipe_buffer *
 539 trace_screen_user_buffer_create(struct pipe_screen *_screen,
 540                                 void *data,
 541                                 unsigned size)
 542 {
 543    struct trace_screen *tr_scr = trace_screen(_screen);
 544    struct pipe_screen *screen = tr_scr->screen;
 545    struct pipe_buffer *result;
 546
 547    trace_dump_call_begin("pipe_screen", "user_buffer_create");
 548
 549    trace_dump_arg(ptr, screen);
 550    trace_dump_arg_begin("data");
 551    trace_dump_bytes(data, size);
 552    trace_dump_arg_end();
 553    trace_dump_arg(uint, size);
 554
 555    result = screen->user_buffer_create(screen, data, size);
 556
 557    trace_dump_ret(ptr, result);
 558
 559    trace_dump_call_end();
 560
 561    if(result) {
 562       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 563       result->usage |= TRACE_BUFFER_USAGE_USER;
 564    }
 565
 566    return trace_buffer_create(tr_scr, result);
 567 }
 568
 569
 570 /**
 571  * This function is used to track if data has been changed on a user buffer
 572  * without map/unmap being called.
 573  */
 574 void
 575 trace_screen_user_buffer_update(struct pipe_screen *_screen,
 576                                 struct pipe_buffer *_buffer)
 577 {
 578 #if 0
 579    struct trace_screen *tr_scr = trace_screen(_screen);
 580    struct pipe_screen *screen = tr_scr->screen;
 581    const void *map;
 582
 583    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 584       map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 585       if(map) {
 586          trace_dump_call_begin("pipe_winsys", "buffer_write");
 587
 588          trace_dump_arg(ptr, screen);
 589
 590          trace_dump_arg(ptr, buffer);
 591
 592          trace_dump_arg_begin("data");
 593          trace_dump_bytes(map, buffer->size);
 594          trace_dump_arg_end();
 595
 596          trace_dump_arg_begin("size");
 597          trace_dump_uint(buffer->size);
 598          trace_dump_arg_end();
 599
 600          trace_dump_call_end();
 601
 602          screen->buffer_unmap(screen, buffer);
 603       }
 604    }
 605 #endif
 606 }
 607
 608
 609 static void *
 610 trace_screen_buffer_map(struct pipe_screen *_screen,
 611                         struct pipe_buffer *_buffer,
 612                         unsigned usage)
 613 {
 614    struct trace_screen *tr_scr = trace_screen(_screen);
 615    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 616    struct pipe_screen *screen = tr_scr->screen;
 617    struct pipe_buffer *buffer = tr_buf->buffer;
 618    void *map;
 619
 620    assert(screen->buffer_map);
 621    map = screen->buffer_map(screen, buffer, usage);
 622    if(map) {
 623       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 624          tr_buf->map = map;
 625       }
 626    }
 627
 628    return map;
 629 }
 630
 631
 632 static void *
 633 trace_screen_buffer_map_range(struct pipe_screen *_screen,
 634                               struct pipe_buffer *_buffer,
 635                               unsigned offset,
 636                               unsigned length,
 637                               unsigned usage)
 638 {
 639    struct trace_screen *tr_scr = trace_screen(_screen);
 640    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 641    struct pipe_screen *screen = tr_scr->screen;
 642    struct pipe_buffer *buffer = tr_buf->buffer;
 643    void *map;
 644
 645    assert(screen->buffer_map_range);
 646    map = screen->buffer_map_range(screen, buffer, offset, length, usage);
 647    if(map) {
 648       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 649          tr_buf->map = map;
 650       }
 651    }
 652
 653    return map;
 654 }
 655
 656
 657 static void
 658 buffer_write(struct pipe_screen *screen,
 659              struct pipe_buffer *buffer,
 660              unsigned offset,
 661              const char *map,
 662              unsigned size)
 663 {
 664    assert(map);
 665
 666    trace_dump_call_begin("pipe_screen", "buffer_write");
 667
 668    trace_dump_arg(ptr, screen);
 669
 670    trace_dump_arg(ptr, buffer);
 671
 672    trace_dump_arg(uint, offset);
 673
 674    trace_dump_arg_begin("data");
 675    trace_dump_bytes(map + offset, size);
 676    trace_dump_arg_end();
 677
 678    trace_dump_arg(uint, size);
 679
 680    trace_dump_call_end();
 681
 682 }
 683
 684
 685 static void
 686 trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 687                                        struct pipe_buffer *_buffer,
 688                                        unsigned offset,
 689                                        unsigned length)
 690 {
 691    struct trace_screen *tr_scr = trace_screen(_screen);
 692    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 693    struct pipe_screen *screen = tr_scr->screen;
 694    struct pipe_buffer *buffer = tr_buf->buffer;
 695
 696    assert(tr_buf->map);
 697    buffer_write(screen, buffer, offset, tr_buf->map, length);
 698    tr_buf->range_flushed = TRUE;
 699    screen->buffer_flush_mapped_range(screen, buffer, offset, length);
 700 }
 701
 702
 703 static void
 704 trace_screen_buffer_unmap(struct pipe_screen *_screen,
 705                           struct pipe_buffer *_buffer)
 706 {
 707    struct trace_screen *tr_scr = trace_screen(_screen);
 708    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 709    struct pipe_screen *screen = tr_scr->screen;
 710    struct pipe_buffer *buffer = tr_buf->buffer;
 711
 712    if (tr_buf->map && !tr_buf->range_flushed)
 713       buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
 714    tr_buf->map = NULL;
 715    tr_buf->range_flushed = FALSE;
 716    screen->buffer_unmap(screen, buffer);
 717 }
 718
 719
 720 static void
 721 trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
 722 {
 723    struct trace_screen *tr_scr = trace_screen(_buffer->screen);
 724    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 725    struct pipe_screen *screen = tr_scr->screen;
 726    struct pipe_buffer *buffer = tr_buf->buffer;
 727
 728    trace_dump_call_begin("pipe_screen", "buffer_destroy");
 729
 730    trace_dump_arg(ptr, screen);
 731    trace_dump_arg(ptr, buffer);
 732
 733    trace_dump_call_end();
 734
 735    trace_buffer_destroy(tr_scr, _buffer);
 736 }
 737
 738
 739 /********************************************************************
 740  * fence
 741  */
 742
 743
 744 static void
 745 trace_screen_fence_reference(struct pipe_screen *_screen,
 746                              struct pipe_fence_handle **pdst,
 747                              struct pipe_fence_handle *src)
 748 {
 749    struct trace_screen *tr_scr = trace_screen(_screen);
 750    struct pipe_screen *screen = tr_scr->screen;
 751    struct pipe_fence_handle *dst;
 752
 753    assert(pdst);
 754    dst = *pdst;
 755
 756    trace_dump_call_begin("pipe_screen", "fence_reference");
 757
 758    trace_dump_arg(ptr, screen);
 759    trace_dump_arg(ptr, dst);
 760    trace_dump_arg(ptr, src);
 761
 762    screen->fence_reference(screen, pdst, src);
 763
 764    trace_dump_call_end();
 765 }
 766
 767
 768 static int
 769 trace_screen_fence_signalled(struct pipe_screen *_screen,
 770                              struct pipe_fence_handle *fence,
 771                              unsigned flags)
 772 {
 773    struct trace_screen *tr_scr = trace_screen(_screen);
 774    struct pipe_screen *screen = tr_scr->screen;
 775    int result;
 776
 777    trace_dump_call_begin("pipe_screen", "fence_signalled");
 778
 779    trace_dump_arg(ptr, screen);
 780    trace_dump_arg(ptr, fence);
 781    trace_dump_arg(uint, flags);
 782
 783    result = screen->fence_signalled(screen, fence, flags);
 784
 785    trace_dump_ret(int, result);
 786
 787    trace_dump_call_end();
 788
 789    return result;
 790 }
 791
 792
 793 static int
 794 trace_screen_fence_finish(struct pipe_screen *_screen,
 795                           struct pipe_fence_handle *fence,
 796                           unsigned flags)
 797 {
 798    struct trace_screen *tr_scr = trace_screen(_screen);
 799    struct pipe_screen *screen = tr_scr->screen;
 800    int result;
 801
 802    trace_dump_call_begin("pipe_screen", "fence_finish");
 803
 804    trace_dump_arg(ptr, screen);
 805    trace_dump_arg(ptr, fence);
 806    trace_dump_arg(uint, flags);
 807
 808    result = screen->fence_finish(screen, fence, flags);
 809
 810    trace_dump_ret(int, result);
 811
 812    trace_dump_call_end();
 813
 814    return result;
 815 }
 816
 817
 818 /********************************************************************
 819  * screen
 820  */
 821
 822 static void
 823 trace_screen_destroy(struct pipe_screen *_screen)
 824 {
 825    struct trace_screen *tr_scr = trace_screen(_screen);
 826    struct pipe_screen *screen = tr_scr->screen;
 827
 828    trace_dump_call_begin("pipe_screen", "destroy");
 829    trace_dump_arg(ptr, screen);
 830    trace_dump_call_end();
 831    trace_dump_trace_end();
 832
 833    if (tr_scr->rbug)
 834       trace_rbug_stop(tr_scr->rbug);
 835
 836    screen->destroy(screen);
 837
 838    FREE(tr_scr);
 839 }
 840
 841 boolean
 842 trace_enabled(void)
 843 {
 844    static boolean firstrun = TRUE;
 845
 846    if (!firstrun)
 847       return trace;
 848    firstrun = FALSE;
 849
 850    trace_dump_init();
 851
 852    if(trace_dump_trace_begin()) {
 853       trace_dumping_start();
 854       trace = TRUE;
 855    }
 856
 857    if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
 858       trace = TRUE;
 859       rbug = TRUE;
 860    }
 861
 862    return trace;
 863 }
 864
 865 struct pipe_screen *
 866 trace_screen_create(struct pipe_screen *screen)
 867 {
 868    struct trace_screen *tr_scr;
 869    struct pipe_winsys *winsys;
 870
 871    if(!screen)
 872       goto error1;
 873
 874    if (!trace_enabled())
 875       goto error1;
 876
 877    trace_dump_call_begin("", "pipe_screen_create");
 878
 879    tr_scr = CALLOC_STRUCT(trace_screen);
 880    if(!tr_scr)
 881       goto error2;
 882
 883 #if 0
 884    winsys = trace_winsys_create(screen->winsys);
 885    if(!winsys)
 886       goto error3;
 887 #else
 888    winsys = screen->winsys;
 889 #endif
 890    pipe_mutex_init(tr_scr->list_mutex);
 891    make_empty_list(&tr_scr->buffers);
 892    make_empty_list(&tr_scr->contexts);
 893    make_empty_list(&tr_scr->textures);
 894    make_empty_list(&tr_scr->surfaces);
 895    make_empty_list(&tr_scr->transfers);
 896
 897    tr_scr->base.winsys = winsys;
 898    tr_scr->base.destroy = trace_screen_destroy;
 899    tr_scr->base.get_name = trace_screen_get_name;
 900    tr_scr->base.get_vendor = trace_screen_get_vendor;
 901    tr_scr->base.get_param = trace_screen_get_param;
 902    tr_scr->base.get_paramf = trace_screen_get_paramf;
 903    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 904    tr_scr->base.texture_create = trace_screen_texture_create;
 905    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
 906    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 907    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 908    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 909    tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
 910    tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
 911    tr_scr->base.transfer_map = trace_screen_transfer_map;
 912    tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
 913    tr_scr->base.buffer_create = trace_screen_buffer_create;
 914    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 915    tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
 916    if (screen->buffer_map)
 917       tr_scr->base.buffer_map = trace_screen_buffer_map;
 918    if (screen->buffer_map_range)
 919       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 920    if (screen->buffer_flush_mapped_range)
 921       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 922    if (screen->buffer_unmap)
 923       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 924    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 925    tr_scr->base.fence_reference = trace_screen_fence_reference;
 926    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 927    tr_scr->base.fence_finish = trace_screen_fence_finish;
 928    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 929    tr_scr->screen = screen;
 930
 931    trace_dump_ret(ptr, screen);
 932    trace_dump_call_end();
 933
 934    if (rbug)
 935       tr_scr->rbug = trace_rbug_start(tr_scr);
 936
 937    return &tr_scr->base;
 938
 939 #if 0
 940 error3:
 941    FREE(tr_scr);
 942 #endif
 943 error2:
 944    trace_dump_ret(ptr, screen);
 945    trace_dump_call_end();
 946    trace_dump_trace_end();
 947 error1:
 948    return screen;
 949 }
 950
 951
 952 struct trace_screen *
 953 trace_screen(struct pipe_screen *screen)
 954 {
 955    assert(screen);
 956    assert(screen->destroy == trace_screen_destroy);
 957    return (struct trace_screen *)screen;
 958 }