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_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
 163    struct trace_surface *tr_surf = trace_surface(tr_tex, _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(tr_scr, _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_scr, _texture);
 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(tr_scr, _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_texture *tr_tex = trace_texture(tr_scr, _surface->texture);
 308    struct trace_surface *tr_surf = trace_surface(tr_tex, _surface);
 309    struct pipe_screen *screen = tr_scr->screen;
 310    struct pipe_surface *surface = tr_surf->surface;
 311
 312    trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
 313
 314    trace_dump_arg(ptr, screen);
 315    trace_dump_arg(ptr, surface);
 316
 317    trace_dump_call_end();
 318
 319    trace_surface_destroy(tr_tex, _surface);
 320 }
 321
 322
 323 /********************************************************************
 324  * transfer
 325  */
 326
 327
 328 static struct pipe_transfer *
 329 trace_screen_get_tex_transfer(struct pipe_screen *_screen,
 330                               struct pipe_texture *_texture,
 331                               unsigned face, unsigned level,
 332                               unsigned zslice,
 333                               enum pipe_transfer_usage usage,
 334                               unsigned x, unsigned y, unsigned w, unsigned h)
 335 {
 336    struct trace_screen *tr_scr = trace_screen(_screen);
 337    struct trace_texture *tr_tex = trace_texture(tr_scr, _texture);
 338    struct pipe_screen *screen = tr_scr->screen;
 339    struct pipe_texture *texture = tr_tex->texture;
 340    struct pipe_transfer *result = NULL;
 341
 342    assert(texture->screen == screen);
 343
 344    trace_dump_call_begin("pipe_screen", "get_tex_transfer");
 345
 346    trace_dump_arg(ptr, screen);
 347    trace_dump_arg(ptr, texture);
 348    trace_dump_arg(uint, face);
 349    trace_dump_arg(uint, level);
 350    trace_dump_arg(uint, zslice);
 351    trace_dump_arg(uint, usage);
 352
 353    trace_dump_arg(uint, x);
 354    trace_dump_arg(uint, y);
 355    trace_dump_arg(uint, w);
 356    trace_dump_arg(uint, h);
 357
 358    result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
 359                                      x, y, w, h);
 360
 361    trace_dump_ret(ptr, result);
 362
 363    trace_dump_call_end();
 364
 365    result = trace_transfer_create(tr_tex, result);
 366
 367    return result;
 368 }
 369
 370
 371 static void
 372 trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 373 {
 374    struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
 375    struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
 376    struct trace_transfer *tr_tran = trace_transfer(tr_tex, _transfer);
 377    struct pipe_screen *screen = tr_scr->screen;
 378    struct pipe_transfer *transfer = tr_tran->transfer;
 379
 380    trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
 381
 382    trace_dump_arg(ptr, screen);
 383    trace_dump_arg(ptr, transfer);
 384
 385    trace_dump_call_end();
 386
 387    trace_transfer_destroy(tr_tex, _transfer);
 388 }
 389
 390
 391 static void *
 392 trace_screen_transfer_map(struct pipe_screen *_screen,
 393                           struct pipe_transfer *_transfer)
 394 {
 395    struct trace_screen *tr_scr = trace_screen(_screen);
 396    struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
 397    struct trace_transfer *tr_trans = trace_transfer(tr_tex, _transfer);
 398    struct pipe_screen *screen = tr_scr->screen;
 399    struct pipe_transfer *transfer = tr_trans->transfer;
 400    void *map;
 401
 402    map = screen->transfer_map(screen, transfer);
 403    if(map) {
 404       if(transfer->usage != PIPE_TRANSFER_READ) {
 405          assert(!tr_trans->map);
 406          tr_trans->map = map;
 407       }
 408    }
 409
 410    return map;
 411 }
 412
 413
 414 static void
 415 trace_screen_transfer_unmap(struct pipe_screen *_screen,
 416                            struct pipe_transfer *_transfer)
 417 {
 418    struct trace_screen *tr_scr = trace_screen(_screen);
 419    struct trace_texture *tr_tex = trace_texture(tr_scr, _transfer->texture);
 420    struct trace_transfer *tr_trans = trace_transfer(tr_tex, _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("data");
 434       trace_dump_bytes(tr_trans->map, size);
 435       trace_dump_arg_end();
 436
 437       trace_dump_arg_begin("stride");
 438       trace_dump_uint(transfer->stride);
 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    /* XXX: Mark the user buffers. (we should wrap pipe_buffers, but is is
 558     * impossible to do so while texture-less surfaces are still around */
 559    if(result) {
 560       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 561       result->usage |= TRACE_BUFFER_USAGE_USER;
 562    }
 563
 564    return trace_buffer_create(tr_scr, result);
 565 }
 566
 567
 568 /**
 569  * This function is used to track if data has been changed on a user buffer
 570  * without map/unmap being called.
 571  */
 572 void
 573 trace_screen_user_buffer_update(struct pipe_screen *_screen,
 574                                 struct pipe_buffer *_buffer)
 575 {
 576 #if 0
 577    struct trace_screen *tr_scr = trace_screen(_screen);
 578    struct pipe_screen *screen = tr_scr->screen;
 579    const void *map;
 580
 581    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 582       map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 583       if(map) {
 584          trace_dump_call_begin("pipe_winsys", "buffer_write");
 585
 586          trace_dump_arg(ptr, screen);
 587
 588          trace_dump_arg(ptr, buffer);
 589
 590          trace_dump_arg_begin("data");
 591          trace_dump_bytes(map, buffer->size);
 592          trace_dump_arg_end();
 593
 594          trace_dump_arg_begin("size");
 595          trace_dump_uint(buffer->size);
 596          trace_dump_arg_end();
 597
 598          trace_dump_call_end();
 599
 600          screen->buffer_unmap(screen, buffer);
 601       }
 602    }
 603 #endif
 604 }
 605
 606
 607 static void *
 608 trace_screen_buffer_map(struct pipe_screen *_screen,
 609                         struct pipe_buffer *_buffer,
 610                         unsigned usage)
 611 {
 612    struct trace_screen *tr_scr = trace_screen(_screen);
 613    struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
 614    struct pipe_screen *screen = tr_scr->screen;
 615    struct pipe_buffer *buffer = tr_buf->buffer;
 616    void *map;
 617
 618    trace_dump_call_begin("pipe_screen", "buffer_map");
 619
 620    trace_dump_arg(ptr, screen);
 621    trace_dump_arg(ptr, buffer);
 622    trace_dump_arg(uint, usage);
 623
 624    assert(screen->buffer_map);
 625    map = screen->buffer_map(screen, buffer, usage);
 626
 627    trace_dump_ret(ptr, map);
 628 #if 0
 629    if(map) {
 630       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 631          assert(!hash_table_get(tr_ws->buffer_maps, buffer));
 632          hash_table_set(tr_ws->buffer_maps, buffer, map);
 633       }
 634    }
 635 #endif
 636
 637    return map;
 638 }
 639
 640
 641 static void *
 642 trace_screen_buffer_map_range(struct pipe_screen *_screen,
 643                               struct pipe_buffer *_buffer,
 644                               unsigned offset,
 645                               unsigned length,
 646                               unsigned usage)
 647 {
 648    struct trace_screen *tr_scr = trace_screen(_screen);
 649    struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
 650    struct pipe_screen *screen = tr_scr->screen;
 651    struct pipe_buffer *buffer = tr_buf->buffer;
 652    void *map;
 653
 654    trace_dump_call_begin("pipe_screen", "buffer_map_range");
 655
 656    trace_dump_arg(ptr, screen);
 657    trace_dump_arg(ptr, buffer);
 658    trace_dump_arg(uint, offset);
 659    trace_dump_arg(uint, length);
 660    trace_dump_arg(uint, usage);
 661
 662    assert(screen->buffer_map_range);
 663    map = screen->buffer_map_range(screen, buffer, offset, length, usage);
 664
 665    trace_dump_ret(ptr, map);
 666
 667    trace_dump_call_end();
 668
 669    return map;
 670 }
 671
 672
 673 static void
 674 trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 675                                        struct pipe_buffer *_buffer,
 676                                        unsigned offset,
 677                                        unsigned length)
 678 {
 679    struct trace_screen *tr_scr = trace_screen(_screen);
 680    struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
 681    struct pipe_screen *screen = tr_scr->screen;
 682    struct pipe_buffer *buffer = tr_buf->buffer;
 683
 684    trace_dump_call_begin("pipe_screen", "buffer_flush_mapped_range");
 685
 686    trace_dump_arg(ptr, screen);
 687    trace_dump_arg(ptr, buffer);
 688    trace_dump_arg(uint, offset);
 689    trace_dump_arg(uint, length);
 690
 691    assert(screen->buffer_flush_mapped_range);
 692    screen->buffer_flush_mapped_range(screen, buffer, offset, length);
 693
 694    trace_dump_call_end();
 695 }
 696
 697
 698 static void
 699 trace_screen_buffer_unmap(struct pipe_screen *_screen,
 700                           struct pipe_buffer *_buffer)
 701 {
 702    struct trace_screen *tr_scr = trace_screen(_screen);
 703    struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
 704    struct pipe_screen *screen = tr_scr->screen;
 705    struct pipe_buffer *buffer = tr_buf->buffer;
 706 #if 0
 707    const void *map;
 708
 709    map = hash_table_get(tr_ws->buffer_maps, buffer);
 710    if(map) {
 711       trace_dump_call_begin("pipe_winsys", "buffer_write");
 712
 713       trace_dump_arg(ptr, winsys);
 714
 715       trace_dump_arg(ptr, buffer);
 716
 717       trace_dump_arg_begin("data");
 718       trace_dump_bytes(map, buffer->size);
 719       trace_dump_arg_end();
 720
 721       trace_dump_arg_begin("size");
 722       trace_dump_uint(buffer->size);
 723       trace_dump_arg_end();
 724
 725       trace_dump_call_end();
 726
 727       hash_table_remove(tr_ws->buffer_maps, buffer);
 728    }
 729 #endif
 730
 731    trace_dump_call_begin("pipe_screen", "buffer_unmap");
 732
 733    trace_dump_arg(ptr, screen);
 734    trace_dump_arg(ptr, buffer);
 735
 736    assert(screen->buffer_unmap);
 737    screen->buffer_unmap(screen, buffer);
 738
 739    trace_dump_call_end();
 740 }
 741
 742
 743 static void
 744 trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
 745 {
 746    struct trace_screen *tr_scr = trace_screen(_buffer->screen);
 747    struct trace_buffer *tr_buf = trace_buffer(tr_scr, _buffer);
 748    struct pipe_screen *screen = tr_scr->screen;
 749    struct pipe_buffer *buffer = tr_buf->buffer;
 750
 751    trace_dump_call_begin("pipe_screen", "buffer_destroy");
 752
 753    trace_dump_arg(ptr, screen);
 754    trace_dump_arg(ptr, buffer);
 755
 756    trace_dump_call_end();
 757
 758    trace_buffer_destroy(tr_scr, _buffer);
 759 }
 760
 761
 762 /********************************************************************
 763  * fence
 764  */
 765
 766
 767 static void
 768 trace_screen_fence_reference(struct pipe_screen *_screen,
 769                              struct pipe_fence_handle **dst,
 770                              struct pipe_fence_handle *src)
 771 {
 772    struct trace_screen *tr_scr = trace_screen(_screen);
 773    struct pipe_screen *screen = tr_scr->screen;
 774
 775    trace_dump_call_begin("pipe_screen", "fence_reference");
 776
 777    trace_dump_arg(ptr, screen);
 778    trace_dump_arg(ptr, dst);
 779    trace_dump_arg(ptr, src);
 780
 781    screen->fence_reference(screen, dst, src);
 782
 783    trace_dump_call_end();
 784 }
 785
 786
 787 static int
 788 trace_screen_fence_signalled(struct pipe_screen *_screen,
 789                              struct pipe_fence_handle *fence,
 790                              unsigned flag)
 791 {
 792    struct trace_screen *tr_scr = trace_screen(_screen);
 793    struct pipe_screen *screen = tr_scr->screen;
 794    int result;
 795
 796    trace_dump_call_begin("pipe_screen", "fence_signalled");
 797
 798    trace_dump_arg(ptr, screen);
 799    trace_dump_arg(ptr, fence);
 800    trace_dump_arg(uint, flag);
 801
 802    result = screen->fence_signalled(screen, fence, flag);
 803
 804    trace_dump_ret(int, result);
 805
 806    trace_dump_call_end();
 807
 808    return result;
 809 }
 810
 811
 812 static int
 813 trace_screen_fence_finish(struct pipe_screen *_screen,
 814                           struct pipe_fence_handle *fence,
 815                           unsigned flag)
 816 {
 817    struct trace_screen *tr_scr = trace_screen(_screen);
 818    struct pipe_screen *screen = tr_scr->screen;
 819    int result;
 820
 821    trace_dump_call_begin("pipe_screen", "fence_finish");
 822
 823    trace_dump_arg(ptr, screen);
 824    trace_dump_arg(ptr, fence);
 825    trace_dump_arg(uint, flag);
 826
 827    result = screen->fence_finish(screen, fence, flag);
 828
 829    trace_dump_ret(int, result);
 830
 831    trace_dump_call_end();
 832
 833    return result;
 834 }
 835
 836
 837 /********************************************************************
 838  * screen
 839  */
 840
 841 static void
 842 trace_screen_destroy(struct pipe_screen *_screen)
 843 {
 844    struct trace_screen *tr_scr = trace_screen(_screen);
 845    struct pipe_screen *screen = tr_scr->screen;
 846
 847    trace_dump_call_begin("pipe_screen", "destroy");
 848
 849    trace_dump_arg(ptr, screen);
 850
 851    screen->destroy(screen);
 852
 853    trace_dump_call_end();
 854
 855    trace_dump_trace_end();
 856
 857    FREE(tr_scr);
 858 }
 859
 860
 861 struct pipe_screen *
 862 trace_screen_create(struct pipe_screen *screen)
 863 {
 864    struct trace_screen *tr_scr;
 865    struct pipe_winsys *winsys;
 866
 867    if(!screen)
 868       goto error1;
 869
 870    if(!trace_dump_trace_begin())
 871       goto error1;
 872
 873    trace_dump_call_begin("", "pipe_screen_create");
 874
 875    tr_scr = CALLOC_STRUCT(trace_screen);
 876    if(!tr_scr)
 877       goto error2;
 878
 879 #if 0
 880    winsys = trace_winsys_create(screen->winsys);
 881    if(!winsys)
 882       goto error3;
 883 #else
 884    winsys = screen->winsys;
 885 #endif
 886
 887    tr_scr->base.winsys = winsys;
 888    tr_scr->base.destroy = trace_screen_destroy;
 889    tr_scr->base.get_name = trace_screen_get_name;
 890    tr_scr->base.get_vendor = trace_screen_get_vendor;
 891    tr_scr->base.get_param = trace_screen_get_param;
 892    tr_scr->base.get_paramf = trace_screen_get_paramf;
 893    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 894    tr_scr->base.texture_create = trace_screen_texture_create;
 895    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
 896    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 897    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 898    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 899    tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
 900    tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
 901    tr_scr->base.transfer_map = trace_screen_transfer_map;
 902    tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
 903    tr_scr->base.buffer_create = trace_screen_buffer_create;
 904    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 905    tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
 906    if (screen->buffer_map)
 907       tr_scr->base.buffer_map = trace_screen_buffer_map;
 908    if (screen->buffer_map_range)
 909       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 910    if (screen->buffer_flush_mapped_range)
 911       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 912    if (screen->buffer_unmap)
 913       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 914    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 915    tr_scr->base.fence_reference = trace_screen_fence_reference;
 916    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 917    tr_scr->base.fence_finish = trace_screen_fence_finish;
 918    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 919    tr_scr->screen = screen;
 920
 921    trace_dump_ret(ptr, screen);
 922    trace_dump_call_end();
 923
 924    return &tr_scr->base;
 925
 926 #if 0
 927 error3:
 928    FREE(tr_scr);
 929 #endif
 930 error2:
 931    trace_dump_ret(ptr, screen);
 932    trace_dump_call_end();
 933    trace_dump_trace_end();
 934 error1:
 935    return screen;
 936 }
 937
 938
 939 struct trace_screen *
 940 trace_screen(struct pipe_screen *screen)
 941 {
 942    assert(screen);
 943    assert(screen->destroy == trace_screen_destroy);
 944    return (struct trace_screen *)screen;
 945 }