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_format.h"
  29 #include "util/u_memory.h"
  30 #include "util/u_simple_list.h"
  31
  32 #include "tr_buffer.h"
  33 #include "tr_dump.h"
  34 #include "tr_dump_state.h"
  35 #include "tr_texture.h"
  36 #include "tr_context.h"
  37 #include "tr_screen.h"
  38
  39 #include "util/u_inlines.h"
  40 #include "pipe/p_format.h"
  41
  42
  43 static boolean trace = FALSE;
  44 static boolean rbug = FALSE;
  45
  46 static const char *
  47 trace_screen_get_name(struct pipe_screen *_screen)
  48 {
  49    struct trace_screen *tr_scr = trace_screen(_screen);
  50    struct pipe_screen *screen = tr_scr->screen;
  51    const char *result;
  52
  53    trace_dump_call_begin("pipe_screen", "get_name");
  54
  55    trace_dump_arg(ptr, screen);
  56
  57    result = screen->get_name(screen);
  58
  59    trace_dump_ret(string, result);
  60
  61    trace_dump_call_end();
  62
  63    return result;
  64 }
  65
  66
  67 static const char *
  68 trace_screen_get_vendor(struct pipe_screen *_screen)
  69 {
  70    struct trace_screen *tr_scr = trace_screen(_screen);
  71    struct pipe_screen *screen = tr_scr->screen;
  72    const char *result;
  73
  74    trace_dump_call_begin("pipe_screen", "get_vendor");
  75
  76    trace_dump_arg(ptr, screen);
  77
  78    result = screen->get_vendor(screen);
  79
  80    trace_dump_ret(string, result);
  81
  82    trace_dump_call_end();
  83
  84    return result;
  85 }
  86
  87
  88 static int
  89 trace_screen_get_param(struct pipe_screen *_screen,
  90                        int param)
  91 {
  92    struct trace_screen *tr_scr = trace_screen(_screen);
  93    struct pipe_screen *screen = tr_scr->screen;
  94    int result;
  95
  96    trace_dump_call_begin("pipe_screen", "get_param");
  97
  98    trace_dump_arg(ptr, screen);
  99    trace_dump_arg(int, param);
 100
 101    result = screen->get_param(screen, param);
 102
 103    trace_dump_ret(int, result);
 104
 105    trace_dump_call_end();
 106
 107    return result;
 108 }
 109
 110
 111 static float
 112 trace_screen_get_paramf(struct pipe_screen *_screen,
 113                         int param)
 114 {
 115    struct trace_screen *tr_scr = trace_screen(_screen);
 116    struct pipe_screen *screen = tr_scr->screen;
 117    float result;
 118
 119    trace_dump_call_begin("pipe_screen", "get_paramf");
 120
 121    trace_dump_arg(ptr, screen);
 122    trace_dump_arg(int, param);
 123
 124    result = screen->get_paramf(screen, param);
 125
 126    trace_dump_ret(float, result);
 127
 128    trace_dump_call_end();
 129
 130    return result;
 131 }
 132
 133
 134 static boolean
 135 trace_screen_is_format_supported(struct pipe_screen *_screen,
 136                                  enum pipe_format format,
 137                                  enum pipe_texture_target target,
 138                                  unsigned tex_usage,
 139                                  unsigned geom_flags)
 140 {
 141    struct trace_screen *tr_scr = trace_screen(_screen);
 142    struct pipe_screen *screen = tr_scr->screen;
 143    boolean result;
 144
 145    trace_dump_call_begin("pipe_screen", "is_format_supported");
 146
 147    trace_dump_arg(ptr, screen);
 148    trace_dump_arg(format, format);
 149    trace_dump_arg(int, target);
 150    trace_dump_arg(uint, tex_usage);
 151    trace_dump_arg(uint, geom_flags);
 152
 153    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
 154
 155    trace_dump_ret(bool, result);
 156
 157    trace_dump_call_end();
 158
 159    return result;
 160 }
 161
 162
 163 static struct pipe_context *
 164 trace_screen_context_create(struct pipe_screen *_screen, void *priv)
 165 {
 166    struct trace_screen *tr_scr = trace_screen(_screen);
 167    struct pipe_screen *screen = tr_scr->screen;
 168    struct pipe_context *result;
 169
 170    trace_dump_call_begin("pipe_screen", "context_create");
 171
 172    trace_dump_arg(ptr, screen);
 173
 174    result = screen->context_create(screen, priv);
 175
 176    trace_dump_ret(ptr, result);
 177
 178    trace_dump_call_end();
 179
 180    result = trace_context_create(tr_scr, result);
 181
 182    return result;
 183 }
 184
 185
 186 static void
 187 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
 188                                struct pipe_surface *_surface,
 189                                void *context_private)
 190 {
 191    struct trace_screen *tr_scr = trace_screen(_screen);
 192    struct trace_surface *tr_surf = trace_surface(_surface);
 193    struct pipe_screen *screen = tr_scr->screen;
 194    struct pipe_surface *surface = tr_surf->surface;
 195
 196    trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
 197
 198    trace_dump_arg(ptr, screen);
 199    trace_dump_arg(ptr, surface);
 200    /* XXX: hide, as there is nothing we can do with this
 201    trace_dump_arg(ptr, context_private);
 202    */
 203
 204    screen->flush_frontbuffer(screen, surface, context_private);
 205
 206    trace_dump_call_end();
 207 }
 208
 209
 210 /********************************************************************
 211  * texture
 212  */
 213
 214
 215 static struct pipe_texture *
 216 trace_screen_texture_create(struct pipe_screen *_screen,
 217                             const struct pipe_texture *templat)
 218 {
 219    struct trace_screen *tr_scr = trace_screen(_screen);
 220    struct pipe_screen *screen = tr_scr->screen;
 221    struct pipe_texture *result;
 222
 223    trace_dump_call_begin("pipe_screen", "texture_create");
 224
 225    trace_dump_arg(ptr, screen);
 226    trace_dump_arg(template, templat);
 227
 228    result = screen->texture_create(screen, templat);
 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 static struct pipe_texture *
 240 trace_screen_texture_from_handle(struct pipe_screen *_screen,
 241                                  const struct pipe_texture *templ,
 242                                  struct winsys_handle *handle)
 243 {
 244    struct trace_screen *tr_screen = trace_screen(_screen);
 245    struct pipe_screen *screen = tr_screen->screen;
 246    struct pipe_texture *result;
 247
 248    /* TODO trace call */
 249
 250    result = screen->texture_from_handle(screen, templ, handle);
 251
 252    result = trace_texture_create(trace_screen(_screen), result);
 253
 254    return result;
 255 }
 256
 257 static boolean
 258 trace_screen_texture_get_handle(struct pipe_screen *_screen,
 259                                 struct pipe_texture *_texture,
 260                                 struct winsys_handle *handle)
 261 {
 262    struct trace_screen *tr_screen = trace_screen(_screen);
 263    struct trace_texture *tr_texture = trace_texture(_texture);
 264    struct pipe_screen *screen = tr_screen->screen;
 265    struct pipe_texture *texture = tr_texture->texture;
 266
 267    /* TODO trace call */
 268
 269    return screen->texture_get_handle(screen, texture, handle);
 270 }
 271
 272
 273
 274 static void
 275 trace_screen_texture_destroy(struct pipe_texture *_texture)
 276 {
 277    struct trace_screen *tr_scr = trace_screen(_texture->screen);
 278    struct trace_texture *tr_tex = trace_texture(_texture);
 279    struct pipe_screen *screen = tr_scr->screen;
 280    struct pipe_texture *texture = tr_tex->texture;
 281
 282    assert(texture->screen == screen);
 283
 284    trace_dump_call_begin("pipe_screen", "texture_destroy");
 285
 286    trace_dump_arg(ptr, screen);
 287    trace_dump_arg(ptr, texture);
 288
 289    trace_dump_call_end();
 290
 291    trace_texture_destroy(tr_tex);
 292 }
 293
 294
 295 /********************************************************************
 296  * surface
 297  */
 298
 299
 300 static struct pipe_surface *
 301 trace_screen_get_tex_surface(struct pipe_screen *_screen,
 302                              struct pipe_texture *_texture,
 303                              unsigned face, unsigned level,
 304                              unsigned zslice,
 305                              unsigned usage)
 306 {
 307    struct trace_screen *tr_scr = trace_screen(_screen);
 308    struct trace_texture *tr_tex = trace_texture(_texture);
 309    struct pipe_screen *screen = tr_scr->screen;
 310    struct pipe_texture *texture = tr_tex->texture;
 311    struct pipe_surface *result = NULL;
 312
 313    assert(texture->screen == screen);
 314
 315    trace_dump_call_begin("pipe_screen", "get_tex_surface");
 316
 317    trace_dump_arg(ptr, screen);
 318    trace_dump_arg(ptr, texture);
 319    trace_dump_arg(uint, face);
 320    trace_dump_arg(uint, level);
 321    trace_dump_arg(uint, zslice);
 322    trace_dump_arg(uint, usage);
 323
 324    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 325
 326    trace_dump_ret(ptr, result);
 327
 328    trace_dump_call_end();
 329
 330    result = trace_surface_create(tr_tex, result);
 331
 332    return result;
 333 }
 334
 335
 336 static void
 337 trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
 338 {
 339    struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
 340    struct trace_surface *tr_surf = trace_surface(_surface);
 341    struct pipe_screen *screen = tr_scr->screen;
 342    struct pipe_surface *surface = tr_surf->surface;
 343
 344    trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
 345
 346    trace_dump_arg(ptr, screen);
 347    trace_dump_arg(ptr, surface);
 348
 349    trace_dump_call_end();
 350
 351    trace_surface_destroy(tr_surf);
 352 }
 353
 354
 355 /********************************************************************
 356  * transfer
 357  */
 358
 359
 360 static struct pipe_transfer *
 361 trace_screen_get_tex_transfer(struct pipe_screen *_screen,
 362                               struct pipe_texture *_texture,
 363                               unsigned face, unsigned level,
 364                               unsigned zslice,
 365                               enum pipe_transfer_usage usage,
 366                               unsigned x, unsigned y, unsigned w, unsigned h)
 367 {
 368    struct trace_screen *tr_scr = trace_screen(_screen);
 369    struct trace_texture *tr_tex = trace_texture(_texture);
 370    struct pipe_screen *screen = tr_scr->screen;
 371    struct pipe_texture *texture = tr_tex->texture;
 372    struct pipe_transfer *result = NULL;
 373
 374    assert(texture->screen == screen);
 375
 376    trace_dump_call_begin("pipe_screen", "get_tex_transfer");
 377
 378    trace_dump_arg(ptr, screen);
 379    trace_dump_arg(ptr, texture);
 380    trace_dump_arg(uint, face);
 381    trace_dump_arg(uint, level);
 382    trace_dump_arg(uint, zslice);
 383    trace_dump_arg(uint, usage);
 384
 385    trace_dump_arg(uint, x);
 386    trace_dump_arg(uint, y);
 387    trace_dump_arg(uint, w);
 388    trace_dump_arg(uint, h);
 389
 390    result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
 391                                      x, y, w, h);
 392
 393    trace_dump_ret(ptr, result);
 394
 395    trace_dump_call_end();
 396
 397    if (result)
 398       result = trace_transfer_create(tr_tex, result);
 399
 400    return result;
 401 }
 402
 403
 404 static void
 405 trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 406 {
 407    struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
 408    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 409    struct pipe_screen *screen = tr_scr->screen;
 410    struct pipe_transfer *transfer = tr_trans->transfer;
 411
 412    trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
 413
 414    trace_dump_arg(ptr, screen);
 415    trace_dump_arg(ptr, transfer);
 416
 417    trace_dump_call_end();
 418
 419    trace_transfer_destroy(tr_trans);
 420 }
 421
 422
 423 static void *
 424 trace_screen_transfer_map(struct pipe_screen *_screen,
 425                           struct pipe_transfer *_transfer)
 426 {
 427    struct trace_screen *tr_scr = trace_screen(_screen);
 428    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 429    struct pipe_screen *screen = tr_scr->screen;
 430    struct pipe_transfer *transfer = tr_trans->transfer;
 431    void *map;
 432
 433    map = screen->transfer_map(screen, transfer);
 434    if(map) {
 435       if(transfer->usage & PIPE_TRANSFER_WRITE) {
 436          assert(!tr_trans->map);
 437          tr_trans->map = map;
 438       }
 439    }
 440
 441    return map;
 442 }
 443
 444
 445 static void
 446 trace_screen_transfer_unmap(struct pipe_screen *_screen,
 447                            struct pipe_transfer *_transfer)
 448 {
 449    struct trace_screen *tr_scr = trace_screen(_screen);
 450    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 451    struct pipe_screen *screen = tr_scr->screen;
 452    struct pipe_transfer *transfer = tr_trans->transfer;
 453
 454    if(tr_trans->map) {
 455       size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
 456
 457       trace_dump_call_begin("pipe_screen", "transfer_write");
 458
 459       trace_dump_arg(ptr, screen);
 460
 461       trace_dump_arg(ptr, transfer);
 462
 463       trace_dump_arg_begin("stride");
 464       trace_dump_uint(transfer->stride);
 465       trace_dump_arg_end();
 466
 467       trace_dump_arg_begin("data");
 468       trace_dump_bytes(tr_trans->map, size);
 469       trace_dump_arg_end();
 470
 471       trace_dump_arg_begin("size");
 472       trace_dump_uint(size);
 473       trace_dump_arg_end();
 474
 475       trace_dump_call_end();
 476
 477       tr_trans->map = NULL;
 478    }
 479
 480    screen->transfer_unmap(screen, transfer);
 481 }
 482
 483
 484 /********************************************************************
 485  * buffer
 486  */
 487
 488
 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(_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(_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(_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(_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(_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    trace_dump_arg(ptr, screen);
 821    trace_dump_call_end();
 822    trace_dump_trace_end();
 823
 824    if (tr_scr->rbug)
 825       trace_rbug_stop(tr_scr->rbug);
 826
 827    screen->destroy(screen);
 828
 829    FREE(tr_scr);
 830 }
 831
 832 boolean
 833 trace_enabled(void)
 834 {
 835    static boolean firstrun = TRUE;
 836
 837    if (!firstrun)
 838       return trace;
 839    firstrun = FALSE;
 840
 841    trace_dump_init();
 842
 843    if(trace_dump_trace_begin()) {
 844       trace_dumping_start();
 845       trace = TRUE;
 846    }
 847
 848    if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
 849       trace = TRUE;
 850       rbug = TRUE;
 851    }
 852
 853    return trace;
 854 }
 855
 856 struct pipe_screen *
 857 trace_screen_create(struct pipe_screen *screen)
 858 {
 859    struct trace_screen *tr_scr;
 860    struct pipe_winsys *winsys;
 861
 862    if(!screen)
 863       goto error1;
 864
 865    if (!trace_enabled())
 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    assert(screen->context_create);
 896    tr_scr->base.context_create = trace_screen_context_create;
 897    tr_scr->base.texture_create = trace_screen_texture_create;
 898    tr_scr->base.texture_from_handle = trace_screen_texture_from_handle;
 899    tr_scr->base.texture_get_handle = trace_screen_texture_get_handle;
 900    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 901    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 902    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 903    tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
 904    tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
 905    tr_scr->base.transfer_map = trace_screen_transfer_map;
 906    tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
 907    tr_scr->base.buffer_create = trace_screen_buffer_create;
 908    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 909    if (screen->buffer_map)
 910       tr_scr->base.buffer_map = trace_screen_buffer_map;
 911    if (screen->buffer_map_range)
 912       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 913    if (screen->buffer_flush_mapped_range)
 914       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 915    if (screen->buffer_unmap)
 916       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 917    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 918    tr_scr->base.fence_reference = trace_screen_fence_reference;
 919    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 920    tr_scr->base.fence_finish = trace_screen_fence_finish;
 921    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 922    tr_scr->screen = screen;
 923
 924    trace_dump_ret(ptr, screen);
 925    trace_dump_call_end();
 926
 927    if (rbug)
 928       tr_scr->rbug = trace_rbug_start(tr_scr);
 929
 930    return &tr_scr->base;
 931
 932 #if 0
 933 error3:
 934    FREE(tr_scr);
 935 #endif
 936 error2:
 937    trace_dump_ret(ptr, screen);
 938    trace_dump_call_end();
 939    trace_dump_trace_end();
 940 error1:
 941    return screen;
 942 }
 943
 944
 945 struct trace_screen *
 946 trace_screen(struct pipe_screen *screen)
 947 {
 948    assert(screen);
 949    assert(screen->destroy == trace_screen_destroy);
 950    return (struct trace_screen *)screen;
 951 }