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
 240 static struct pipe_texture *
 241 trace_screen_texture_blanket(struct pipe_screen *_screen,
 242                              const struct pipe_texture *templat,
 243                              const unsigned *ppitch,
 244                              struct pipe_buffer *_buffer)
 245 {
 246    struct trace_screen *tr_scr = trace_screen(_screen);
 247    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 248    struct pipe_screen *screen = tr_scr->screen;
 249    struct pipe_buffer *buffer = tr_buf->buffer;
 250    unsigned pitch = *ppitch;
 251    struct pipe_texture *result;
 252
 253    trace_dump_call_begin("pipe_screen", "texture_blanket");
 254
 255    trace_dump_arg(ptr, screen);
 256    trace_dump_arg(template, templat);
 257    trace_dump_arg(uint, pitch);
 258    trace_dump_arg(ptr, buffer);
 259
 260    result = screen->texture_blanket(screen, templat, ppitch, buffer);
 261
 262    trace_dump_ret(ptr, result);
 263
 264    trace_dump_call_end();
 265
 266    result = trace_texture_create(tr_scr, result);
 267
 268    return result;
 269 }
 270
 271
 272 static void
 273 trace_screen_texture_destroy(struct pipe_texture *_texture)
 274 {
 275    struct trace_screen *tr_scr = trace_screen(_texture->screen);
 276    struct trace_texture *tr_tex = trace_texture(_texture);
 277    struct pipe_screen *screen = tr_scr->screen;
 278    struct pipe_texture *texture = tr_tex->texture;
 279
 280    assert(texture->screen == screen);
 281
 282    trace_dump_call_begin("pipe_screen", "texture_destroy");
 283
 284    trace_dump_arg(ptr, screen);
 285    trace_dump_arg(ptr, texture);
 286
 287    trace_dump_call_end();
 288
 289    trace_texture_destroy(tr_tex);
 290 }
 291
 292
 293 /********************************************************************
 294  * surface
 295  */
 296
 297
 298 static struct pipe_surface *
 299 trace_screen_get_tex_surface(struct pipe_screen *_screen,
 300                              struct pipe_texture *_texture,
 301                              unsigned face, unsigned level,
 302                              unsigned zslice,
 303                              unsigned usage)
 304 {
 305    struct trace_screen *tr_scr = trace_screen(_screen);
 306    struct trace_texture *tr_tex = trace_texture(_texture);
 307    struct pipe_screen *screen = tr_scr->screen;
 308    struct pipe_texture *texture = tr_tex->texture;
 309    struct pipe_surface *result = NULL;
 310
 311    assert(texture->screen == screen);
 312
 313    trace_dump_call_begin("pipe_screen", "get_tex_surface");
 314
 315    trace_dump_arg(ptr, screen);
 316    trace_dump_arg(ptr, texture);
 317    trace_dump_arg(uint, face);
 318    trace_dump_arg(uint, level);
 319    trace_dump_arg(uint, zslice);
 320    trace_dump_arg(uint, usage);
 321
 322    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 323
 324    trace_dump_ret(ptr, result);
 325
 326    trace_dump_call_end();
 327
 328    result = trace_surface_create(tr_tex, result);
 329
 330    return result;
 331 }
 332
 333
 334 static void
 335 trace_screen_tex_surface_destroy(struct pipe_surface *_surface)
 336 {
 337    struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
 338    struct trace_surface *tr_surf = trace_surface(_surface);
 339    struct pipe_screen *screen = tr_scr->screen;
 340    struct pipe_surface *surface = tr_surf->surface;
 341
 342    trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
 343
 344    trace_dump_arg(ptr, screen);
 345    trace_dump_arg(ptr, surface);
 346
 347    trace_dump_call_end();
 348
 349    trace_surface_destroy(tr_surf);
 350 }
 351
 352
 353 /********************************************************************
 354  * transfer
 355  */
 356
 357
 358 static struct pipe_transfer *
 359 trace_screen_get_tex_transfer(struct pipe_screen *_screen,
 360                               struct pipe_texture *_texture,
 361                               unsigned face, unsigned level,
 362                               unsigned zslice,
 363                               enum pipe_transfer_usage usage,
 364                               unsigned x, unsigned y, unsigned w, unsigned h)
 365 {
 366    struct trace_screen *tr_scr = trace_screen(_screen);
 367    struct trace_texture *tr_tex = trace_texture(_texture);
 368    struct pipe_screen *screen = tr_scr->screen;
 369    struct pipe_texture *texture = tr_tex->texture;
 370    struct pipe_transfer *result = NULL;
 371
 372    assert(texture->screen == screen);
 373
 374    trace_dump_call_begin("pipe_screen", "get_tex_transfer");
 375
 376    trace_dump_arg(ptr, screen);
 377    trace_dump_arg(ptr, texture);
 378    trace_dump_arg(uint, face);
 379    trace_dump_arg(uint, level);
 380    trace_dump_arg(uint, zslice);
 381    trace_dump_arg(uint, usage);
 382
 383    trace_dump_arg(uint, x);
 384    trace_dump_arg(uint, y);
 385    trace_dump_arg(uint, w);
 386    trace_dump_arg(uint, h);
 387
 388    result = screen->get_tex_transfer(screen, texture, face, level, zslice, usage,
 389                                      x, y, w, h);
 390
 391    trace_dump_ret(ptr, result);
 392
 393    trace_dump_call_end();
 394
 395    if (result)
 396       result = trace_transfer_create(tr_tex, result);
 397
 398    return result;
 399 }
 400
 401
 402 static void
 403 trace_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 404 {
 405    struct trace_screen *tr_scr = trace_screen(_transfer->texture->screen);
 406    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 407    struct pipe_screen *screen = tr_scr->screen;
 408    struct pipe_transfer *transfer = tr_trans->transfer;
 409
 410    trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
 411
 412    trace_dump_arg(ptr, screen);
 413    trace_dump_arg(ptr, transfer);
 414
 415    trace_dump_call_end();
 416
 417    trace_transfer_destroy(tr_trans);
 418 }
 419
 420
 421 static void *
 422 trace_screen_transfer_map(struct pipe_screen *_screen,
 423                           struct pipe_transfer *_transfer)
 424 {
 425    struct trace_screen *tr_scr = trace_screen(_screen);
 426    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 427    struct pipe_screen *screen = tr_scr->screen;
 428    struct pipe_transfer *transfer = tr_trans->transfer;
 429    void *map;
 430
 431    map = screen->transfer_map(screen, transfer);
 432    if(map) {
 433       if(transfer->usage & PIPE_TRANSFER_WRITE) {
 434          assert(!tr_trans->map);
 435          tr_trans->map = map;
 436       }
 437    }
 438
 439    return map;
 440 }
 441
 442
 443 static void
 444 trace_screen_transfer_unmap(struct pipe_screen *_screen,
 445                            struct pipe_transfer *_transfer)
 446 {
 447    struct trace_screen *tr_scr = trace_screen(_screen);
 448    struct trace_transfer *tr_trans = trace_transfer(_transfer);
 449    struct pipe_screen *screen = tr_scr->screen;
 450    struct pipe_transfer *transfer = tr_trans->transfer;
 451
 452    if(tr_trans->map) {
 453       size_t size = util_format_get_nblocksy(transfer->texture->format, transfer->height) * transfer->stride;
 454
 455       trace_dump_call_begin("pipe_screen", "transfer_write");
 456
 457       trace_dump_arg(ptr, screen);
 458
 459       trace_dump_arg(ptr, transfer);
 460
 461       trace_dump_arg_begin("stride");
 462       trace_dump_uint(transfer->stride);
 463       trace_dump_arg_end();
 464
 465       trace_dump_arg_begin("data");
 466       trace_dump_bytes(tr_trans->map, size);
 467       trace_dump_arg_end();
 468
 469       trace_dump_arg_begin("size");
 470       trace_dump_uint(size);
 471       trace_dump_arg_end();
 472
 473       trace_dump_call_end();
 474
 475       tr_trans->map = NULL;
 476    }
 477
 478    screen->transfer_unmap(screen, transfer);
 479 }
 480
 481
 482 /********************************************************************
 483  * buffer
 484  */
 485
 486
 487 static struct pipe_buffer *
 488 trace_screen_surface_buffer_create(struct pipe_screen *_screen,
 489                                    unsigned width, unsigned height,
 490                                    enum pipe_format format,
 491                                    unsigned usage,
 492                                    unsigned tex_usage,
 493                                    unsigned *pstride)
 494 {
 495    struct trace_screen *tr_scr = trace_screen(_screen);
 496    struct pipe_screen *screen = tr_scr->screen;
 497    unsigned stride;
 498    struct pipe_buffer *result;
 499
 500    trace_dump_call_begin("pipe_screen", "surface_buffer_create");
 501
 502    trace_dump_arg(ptr, screen);
 503    trace_dump_arg(uint, width);
 504    trace_dump_arg(uint, height);
 505    trace_dump_arg(format, format);
 506    trace_dump_arg(uint, usage);
 507    trace_dump_arg(uint, tex_usage);
 508
 509    result = screen->surface_buffer_create(screen,
 510                                           width, height,
 511                                           format,
 512                                           usage,
 513                                           tex_usage,
 514                                           pstride);
 515
 516    stride = *pstride;
 517
 518    trace_dump_arg(uint, stride);
 519
 520    trace_dump_ret(ptr, result);
 521
 522    trace_dump_call_end();
 523
 524    return trace_buffer_create(tr_scr, result);
 525 }
 526
 527
 528 static struct pipe_buffer *
 529 trace_screen_buffer_create(struct pipe_screen *_screen,
 530                            unsigned alignment,
 531                            unsigned usage,
 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", "buffer_create");
 539
 540    trace_dump_arg(ptr, screen);
 541    trace_dump_arg(uint, alignment);
 542    trace_dump_arg(uint, usage);
 543    trace_dump_arg(uint, size);
 544
 545    result = screen->buffer_create(screen, alignment, usage, size);
 546
 547    trace_dump_ret(ptr, result);
 548
 549    trace_dump_call_end();
 550
 551    /* Zero the buffer to avoid dumping uninitialized memory */
 552    if(result->usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 553       void *map;
 554       map = pipe_buffer_map(screen, result, PIPE_BUFFER_USAGE_CPU_WRITE);
 555       if(map) {
 556          memset(map, 0, result->size);
 557          screen->buffer_unmap(screen, result);
 558       }
 559    }
 560
 561    return trace_buffer_create(tr_scr, result);
 562 }
 563
 564
 565 static struct pipe_buffer *
 566 trace_screen_user_buffer_create(struct pipe_screen *_screen,
 567                                 void *data,
 568                                 unsigned size)
 569 {
 570    struct trace_screen *tr_scr = trace_screen(_screen);
 571    struct pipe_screen *screen = tr_scr->screen;
 572    struct pipe_buffer *result;
 573
 574    trace_dump_call_begin("pipe_screen", "user_buffer_create");
 575
 576    trace_dump_arg(ptr, screen);
 577    trace_dump_arg_begin("data");
 578    trace_dump_bytes(data, size);
 579    trace_dump_arg_end();
 580    trace_dump_arg(uint, size);
 581
 582    result = screen->user_buffer_create(screen, data, size);
 583
 584    trace_dump_ret(ptr, result);
 585
 586    trace_dump_call_end();
 587
 588    if(result) {
 589       assert(!(result->usage & TRACE_BUFFER_USAGE_USER));
 590       result->usage |= TRACE_BUFFER_USAGE_USER;
 591    }
 592
 593    return trace_buffer_create(tr_scr, result);
 594 }
 595
 596
 597 /**
 598  * This function is used to track if data has been changed on a user buffer
 599  * without map/unmap being called.
 600  */
 601 void
 602 trace_screen_user_buffer_update(struct pipe_screen *_screen,
 603                                 struct pipe_buffer *_buffer)
 604 {
 605 #if 0
 606    struct trace_screen *tr_scr = trace_screen(_screen);
 607    struct pipe_screen *screen = tr_scr->screen;
 608    const void *map;
 609
 610    if(buffer && buffer->usage & TRACE_BUFFER_USAGE_USER) {
 611       map = screen->buffer_map(screen, buffer, PIPE_BUFFER_USAGE_CPU_READ);
 612       if(map) {
 613          trace_dump_call_begin("pipe_winsys", "buffer_write");
 614
 615          trace_dump_arg(ptr, screen);
 616
 617          trace_dump_arg(ptr, buffer);
 618
 619          trace_dump_arg_begin("data");
 620          trace_dump_bytes(map, buffer->size);
 621          trace_dump_arg_end();
 622
 623          trace_dump_arg_begin("size");
 624          trace_dump_uint(buffer->size);
 625          trace_dump_arg_end();
 626
 627          trace_dump_call_end();
 628
 629          screen->buffer_unmap(screen, buffer);
 630       }
 631    }
 632 #endif
 633 }
 634
 635
 636 static void *
 637 trace_screen_buffer_map(struct pipe_screen *_screen,
 638                         struct pipe_buffer *_buffer,
 639                         unsigned usage)
 640 {
 641    struct trace_screen *tr_scr = trace_screen(_screen);
 642    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 643    struct pipe_screen *screen = tr_scr->screen;
 644    struct pipe_buffer *buffer = tr_buf->buffer;
 645    void *map;
 646
 647    assert(screen->buffer_map);
 648    map = screen->buffer_map(screen, buffer, usage);
 649    if(map) {
 650       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 651          tr_buf->map = map;
 652       }
 653    }
 654
 655    return map;
 656 }
 657
 658
 659 static void *
 660 trace_screen_buffer_map_range(struct pipe_screen *_screen,
 661                               struct pipe_buffer *_buffer,
 662                               unsigned offset,
 663                               unsigned length,
 664                               unsigned usage)
 665 {
 666    struct trace_screen *tr_scr = trace_screen(_screen);
 667    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 668    struct pipe_screen *screen = tr_scr->screen;
 669    struct pipe_buffer *buffer = tr_buf->buffer;
 670    void *map;
 671
 672    assert(screen->buffer_map_range);
 673    map = screen->buffer_map_range(screen, buffer, offset, length, usage);
 674    if(map) {
 675       if(usage & PIPE_BUFFER_USAGE_CPU_WRITE) {
 676          tr_buf->map = map;
 677       }
 678    }
 679
 680    return map;
 681 }
 682
 683
 684 static void
 685 buffer_write(struct pipe_screen *screen,
 686              struct pipe_buffer *buffer,
 687              unsigned offset,
 688              const char *map,
 689              unsigned size)
 690 {
 691    assert(map);
 692
 693    trace_dump_call_begin("pipe_screen", "buffer_write");
 694
 695    trace_dump_arg(ptr, screen);
 696
 697    trace_dump_arg(ptr, buffer);
 698
 699    trace_dump_arg(uint, offset);
 700
 701    trace_dump_arg_begin("data");
 702    trace_dump_bytes(map + offset, size);
 703    trace_dump_arg_end();
 704
 705    trace_dump_arg(uint, size);
 706
 707    trace_dump_call_end();
 708
 709 }
 710
 711
 712 static void
 713 trace_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 714                                        struct pipe_buffer *_buffer,
 715                                        unsigned offset,
 716                                        unsigned length)
 717 {
 718    struct trace_screen *tr_scr = trace_screen(_screen);
 719    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 720    struct pipe_screen *screen = tr_scr->screen;
 721    struct pipe_buffer *buffer = tr_buf->buffer;
 722
 723    assert(tr_buf->map);
 724    buffer_write(screen, buffer, offset, tr_buf->map, length);
 725    tr_buf->range_flushed = TRUE;
 726    screen->buffer_flush_mapped_range(screen, buffer, offset, length);
 727 }
 728
 729
 730 static void
 731 trace_screen_buffer_unmap(struct pipe_screen *_screen,
 732                           struct pipe_buffer *_buffer)
 733 {
 734    struct trace_screen *tr_scr = trace_screen(_screen);
 735    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 736    struct pipe_screen *screen = tr_scr->screen;
 737    struct pipe_buffer *buffer = tr_buf->buffer;
 738
 739    if (tr_buf->map && !tr_buf->range_flushed)
 740       buffer_write(screen, buffer, 0, tr_buf->map, buffer->size);
 741    tr_buf->map = NULL;
 742    tr_buf->range_flushed = FALSE;
 743    screen->buffer_unmap(screen, buffer);
 744 }
 745
 746
 747 static void
 748 trace_screen_buffer_destroy(struct pipe_buffer *_buffer)
 749 {
 750    struct trace_screen *tr_scr = trace_screen(_buffer->screen);
 751    struct trace_buffer *tr_buf = trace_buffer(_buffer);
 752    struct pipe_screen *screen = tr_scr->screen;
 753    struct pipe_buffer *buffer = tr_buf->buffer;
 754
 755    trace_dump_call_begin("pipe_screen", "buffer_destroy");
 756
 757    trace_dump_arg(ptr, screen);
 758    trace_dump_arg(ptr, buffer);
 759
 760    trace_dump_call_end();
 761
 762    trace_buffer_destroy(tr_scr, _buffer);
 763 }
 764
 765
 766 /********************************************************************
 767  * fence
 768  */
 769
 770
 771 static void
 772 trace_screen_fence_reference(struct pipe_screen *_screen,
 773                              struct pipe_fence_handle **pdst,
 774                              struct pipe_fence_handle *src)
 775 {
 776    struct trace_screen *tr_scr = trace_screen(_screen);
 777    struct pipe_screen *screen = tr_scr->screen;
 778    struct pipe_fence_handle *dst;
 779
 780    assert(pdst);
 781    dst = *pdst;
 782
 783    trace_dump_call_begin("pipe_screen", "fence_reference");
 784
 785    trace_dump_arg(ptr, screen);
 786    trace_dump_arg(ptr, dst);
 787    trace_dump_arg(ptr, src);
 788
 789    screen->fence_reference(screen, pdst, src);
 790
 791    trace_dump_call_end();
 792 }
 793
 794
 795 static int
 796 trace_screen_fence_signalled(struct pipe_screen *_screen,
 797                              struct pipe_fence_handle *fence,
 798                              unsigned flags)
 799 {
 800    struct trace_screen *tr_scr = trace_screen(_screen);
 801    struct pipe_screen *screen = tr_scr->screen;
 802    int result;
 803
 804    trace_dump_call_begin("pipe_screen", "fence_signalled");
 805
 806    trace_dump_arg(ptr, screen);
 807    trace_dump_arg(ptr, fence);
 808    trace_dump_arg(uint, flags);
 809
 810    result = screen->fence_signalled(screen, fence, flags);
 811
 812    trace_dump_ret(int, result);
 813
 814    trace_dump_call_end();
 815
 816    return result;
 817 }
 818
 819
 820 static int
 821 trace_screen_fence_finish(struct pipe_screen *_screen,
 822                           struct pipe_fence_handle *fence,
 823                           unsigned flags)
 824 {
 825    struct trace_screen *tr_scr = trace_screen(_screen);
 826    struct pipe_screen *screen = tr_scr->screen;
 827    int result;
 828
 829    trace_dump_call_begin("pipe_screen", "fence_finish");
 830
 831    trace_dump_arg(ptr, screen);
 832    trace_dump_arg(ptr, fence);
 833    trace_dump_arg(uint, flags);
 834
 835    result = screen->fence_finish(screen, fence, flags);
 836
 837    trace_dump_ret(int, result);
 838
 839    trace_dump_call_end();
 840
 841    return result;
 842 }
 843
 844
 845 /********************************************************************
 846  * screen
 847  */
 848
 849 static void
 850 trace_screen_destroy(struct pipe_screen *_screen)
 851 {
 852    struct trace_screen *tr_scr = trace_screen(_screen);
 853    struct pipe_screen *screen = tr_scr->screen;
 854
 855    trace_dump_call_begin("pipe_screen", "destroy");
 856    trace_dump_arg(ptr, screen);
 857    trace_dump_call_end();
 858    trace_dump_trace_end();
 859
 860    if (tr_scr->rbug)
 861       trace_rbug_stop(tr_scr->rbug);
 862
 863    screen->destroy(screen);
 864
 865    FREE(tr_scr);
 866 }
 867
 868 boolean
 869 trace_enabled(void)
 870 {
 871    static boolean firstrun = TRUE;
 872
 873    if (!firstrun)
 874       return trace;
 875    firstrun = FALSE;
 876
 877    trace_dump_init();
 878
 879    if(trace_dump_trace_begin()) {
 880       trace_dumping_start();
 881       trace = TRUE;
 882    }
 883
 884    if (debug_get_bool_option("GALLIUM_RBUG", FALSE)) {
 885       trace = TRUE;
 886       rbug = TRUE;
 887    }
 888
 889    return trace;
 890 }
 891
 892 struct pipe_screen *
 893 trace_screen_create(struct pipe_screen *screen)
 894 {
 895    struct trace_screen *tr_scr;
 896    struct pipe_winsys *winsys;
 897
 898    if(!screen)
 899       goto error1;
 900
 901    if (!trace_enabled())
 902       goto error1;
 903
 904    trace_dump_call_begin("", "pipe_screen_create");
 905
 906    tr_scr = CALLOC_STRUCT(trace_screen);
 907    if(!tr_scr)
 908       goto error2;
 909
 910 #if 0
 911    winsys = trace_winsys_create(screen->winsys);
 912    if(!winsys)
 913       goto error3;
 914 #else
 915    winsys = screen->winsys;
 916 #endif
 917    pipe_mutex_init(tr_scr->list_mutex);
 918    make_empty_list(&tr_scr->buffers);
 919    make_empty_list(&tr_scr->contexts);
 920    make_empty_list(&tr_scr->textures);
 921    make_empty_list(&tr_scr->surfaces);
 922    make_empty_list(&tr_scr->transfers);
 923
 924    tr_scr->base.winsys = winsys;
 925    tr_scr->base.destroy = trace_screen_destroy;
 926    tr_scr->base.get_name = trace_screen_get_name;
 927    tr_scr->base.get_vendor = trace_screen_get_vendor;
 928    tr_scr->base.get_param = trace_screen_get_param;
 929    tr_scr->base.get_paramf = trace_screen_get_paramf;
 930    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 931    assert(screen->context_create);
 932    tr_scr->base.context_create = trace_screen_context_create;
 933    tr_scr->base.texture_create = trace_screen_texture_create;
 934    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
 935    tr_scr->base.texture_destroy = trace_screen_texture_destroy;
 936    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 937    tr_scr->base.tex_surface_destroy = trace_screen_tex_surface_destroy;
 938    tr_scr->base.get_tex_transfer = trace_screen_get_tex_transfer;
 939    tr_scr->base.tex_transfer_destroy = trace_screen_tex_transfer_destroy;
 940    tr_scr->base.transfer_map = trace_screen_transfer_map;
 941    tr_scr->base.transfer_unmap = trace_screen_transfer_unmap;
 942    tr_scr->base.buffer_create = trace_screen_buffer_create;
 943    tr_scr->base.user_buffer_create = trace_screen_user_buffer_create;
 944    tr_scr->base.surface_buffer_create = trace_screen_surface_buffer_create;
 945    if (screen->buffer_map)
 946       tr_scr->base.buffer_map = trace_screen_buffer_map;
 947    if (screen->buffer_map_range)
 948       tr_scr->base.buffer_map_range = trace_screen_buffer_map_range;
 949    if (screen->buffer_flush_mapped_range)
 950       tr_scr->base.buffer_flush_mapped_range = trace_screen_buffer_flush_mapped_range;
 951    if (screen->buffer_unmap)
 952       tr_scr->base.buffer_unmap = trace_screen_buffer_unmap;
 953    tr_scr->base.buffer_destroy = trace_screen_buffer_destroy;
 954    tr_scr->base.fence_reference = trace_screen_fence_reference;
 955    tr_scr->base.fence_signalled = trace_screen_fence_signalled;
 956    tr_scr->base.fence_finish = trace_screen_fence_finish;
 957    tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
 958    tr_scr->screen = screen;
 959
 960    trace_dump_ret(ptr, screen);
 961    trace_dump_call_end();
 962
 963    if (rbug)
 964       tr_scr->rbug = trace_rbug_start(tr_scr);
 965
 966    return &tr_scr->base;
 967
 968 #if 0
 969 error3:
 970    FREE(tr_scr);
 971 #endif
 972 error2:
 973    trace_dump_ret(ptr, screen);
 974    trace_dump_call_end();
 975    trace_dump_trace_end();
 976 error1:
 977    return screen;
 978 }
 979
 980
 981 struct trace_screen *
 982 trace_screen(struct pipe_screen *screen)
 983 {
 984    assert(screen);
 985    assert(screen->destroy == trace_screen_destroy);
 986    return (struct trace_screen *)screen;
 987 }