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