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