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