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