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