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 "pipe/p_util.h"
  29 #include "util/u_hash_table.h"
  30
  31 #include "tr_dump.h"
  32 #include "tr_state.h"
  33 #include "tr_winsys.h"
  34 #include "tr_screen.h"
  35
  36
  37 static unsigned trace_surface_hash(void *surface)
  38 {
  39    return (unsigned)(uintptr_t)surface;
  40 }
  41
  42
  43 static int trace_surface_compare(void *surface1, void *surface2)
  44 {
  45    return (char *)surface2 - (char *)surface1;
  46 }
  47
  48
  49 static const char *
  50 trace_screen_get_name(struct pipe_screen *_screen)
  51 {
  52    struct trace_screen *tr_scr = trace_screen(_screen);
  53    struct pipe_screen *screen = tr_scr->screen;
  54    const char *result;
  55
  56    trace_dump_call_begin("pipe_screen", "get_name");
  57
  58    trace_dump_arg(ptr, screen);
  59
  60    result = screen->get_name(screen);
  61
  62    trace_dump_ret(string, result);
  63
  64    trace_dump_call_end();
  65
  66    return result;
  67 }
  68
  69
  70 static const char *
  71 trace_screen_get_vendor(struct pipe_screen *_screen)
  72 {
  73    struct trace_screen *tr_scr = trace_screen(_screen);
  74    struct pipe_screen *screen = tr_scr->screen;
  75    const char *result;
  76
  77    trace_dump_call_begin("pipe_screen", "get_vendor");
  78
  79    trace_dump_arg(ptr, screen);
  80
  81    result = screen->get_vendor(screen);
  82
  83    trace_dump_ret(string, result);
  84
  85    trace_dump_call_end();
  86
  87    return result;
  88 }
  89
  90
  91 static int
  92 trace_screen_get_param(struct pipe_screen *_screen,
  93                        int param)
  94 {
  95    struct trace_screen *tr_scr = trace_screen(_screen);
  96    struct pipe_screen *screen = tr_scr->screen;
  97    int result;
  98
  99    trace_dump_call_begin("pipe_screen", "get_param");
 100
 101    trace_dump_arg(ptr, screen);
 102    trace_dump_arg(int, param);
 103
 104    result = screen->get_param(screen, param);
 105
 106    trace_dump_ret(int, result);
 107
 108    trace_dump_call_end();
 109
 110    return result;
 111 }
 112
 113
 114 static float
 115 trace_screen_get_paramf(struct pipe_screen *_screen,
 116                         int param)
 117 {
 118    struct trace_screen *tr_scr = trace_screen(_screen);
 119    struct pipe_screen *screen = tr_scr->screen;
 120    float result;
 121
 122    trace_dump_call_begin("pipe_screen", "get_paramf");
 123
 124    trace_dump_arg(ptr, screen);
 125    trace_dump_arg(int, param);
 126
 127    result = screen->get_paramf(screen, param);
 128
 129    trace_dump_ret(float, result);
 130
 131    trace_dump_call_end();
 132
 133    return result;
 134 }
 135
 136
 137 static boolean
 138 trace_screen_is_format_supported(struct pipe_screen *_screen,
 139                                  enum pipe_format format,
 140                                  enum pipe_texture_target target,
 141                                  unsigned tex_usage,
 142                                  unsigned geom_flags)
 143 {
 144    struct trace_screen *tr_scr = trace_screen(_screen);
 145    struct pipe_screen *screen = tr_scr->screen;
 146    boolean result;
 147
 148    trace_dump_call_begin("pipe_screen", "is_format_supported");
 149
 150    trace_dump_arg(ptr, screen);
 151    trace_dump_arg(format, format);
 152    trace_dump_arg(int, target);
 153    trace_dump_arg(uint, tex_usage);
 154    trace_dump_arg(uint, geom_flags);
 155
 156    result = screen->is_format_supported(screen, format, target, tex_usage, geom_flags);
 157
 158    trace_dump_ret(bool, result);
 159
 160    trace_dump_call_end();
 161
 162    return result;
 163 }
 164
 165
 166 static struct pipe_texture *
 167 trace_screen_texture_create(struct pipe_screen *_screen,
 168                             const struct pipe_texture *templat)
 169 {
 170    struct trace_screen *tr_scr = trace_screen(_screen);
 171    struct pipe_screen *screen = tr_scr->screen;
 172    struct pipe_texture *result;
 173
 174    trace_dump_call_begin("pipe_screen", "texture_create");
 175
 176    trace_dump_arg(ptr, screen);
 177    trace_dump_arg(template, templat);
 178
 179    result = screen->texture_create(screen, templat);
 180
 181    trace_dump_ret(ptr, result);
 182
 183    trace_dump_call_end();
 184
 185    return result;
 186 }
 187
 188
 189 static struct pipe_texture *
 190 trace_screen_texture_blanket(struct pipe_screen *_screen,
 191                              const struct pipe_texture *templat,
 192                              const unsigned *ppitch,
 193                              struct pipe_buffer *buffer)
 194 {
 195    struct trace_screen *tr_scr = trace_screen(_screen);
 196    struct pipe_screen *screen = tr_scr->screen;
 197    unsigned pitch = *ppitch;
 198    struct pipe_texture *result;
 199
 200    trace_dump_call_begin("pipe_screen", "texture_blanket");
 201
 202    trace_dump_arg(ptr, screen);
 203    trace_dump_arg(template, templat);
 204    trace_dump_arg(uint, pitch);
 205    trace_dump_arg(ptr, buffer);
 206
 207    result = screen->texture_blanket(screen, templat, ppitch, buffer);
 208
 209    trace_dump_ret(ptr, result);
 210
 211    trace_dump_call_end();
 212
 213    return result;
 214 }
 215
 216
 217 static void
 218 trace_screen_texture_release(struct pipe_screen *_screen,
 219                              struct pipe_texture **ptexture)
 220 {
 221    struct trace_screen *tr_scr = trace_screen(_screen);
 222    struct pipe_screen *screen = tr_scr->screen;
 223    struct pipe_texture *texture = *ptexture;
 224
 225    trace_dump_call_begin("pipe_screen", "texture_release");
 226
 227    trace_dump_arg(ptr, screen);
 228    trace_dump_arg(ptr, texture);
 229
 230    screen->texture_release(screen, ptexture);
 231
 232    trace_dump_call_end();
 233 }
 234
 235 static struct pipe_surface *
 236 trace_screen_get_tex_surface(struct pipe_screen *_screen,
 237                              struct pipe_texture *texture,
 238                              unsigned face, unsigned level,
 239                              unsigned zslice,
 240                              unsigned usage)
 241 {
 242    struct trace_screen *tr_scr = trace_screen(_screen);
 243    struct pipe_screen *screen = tr_scr->screen;
 244    struct pipe_surface *result;
 245
 246    trace_dump_call_begin("pipe_screen", "get_tex_surface");
 247
 248    trace_dump_arg(ptr, screen);
 249    trace_dump_arg(ptr, texture);
 250    trace_dump_arg(uint, face);
 251    trace_dump_arg(uint, level);
 252    trace_dump_arg(uint, zslice);
 253    trace_dump_arg(uint, usage);
 254
 255    result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
 256
 257    trace_dump_ret(ptr, result);
 258
 259    trace_dump_call_end();
 260
 261    return result;
 262 }
 263
 264
 265 static void
 266 trace_screen_tex_surface_release(struct pipe_screen *_screen,
 267                                  struct pipe_surface **psurface)
 268 {
 269    struct trace_screen *tr_scr = trace_screen(_screen);
 270    struct pipe_screen *screen = tr_scr->screen;
 271    struct pipe_surface *surface = *psurface;
 272
 273    trace_dump_call_begin("pipe_screen", "tex_surface_release");
 274
 275    trace_dump_arg(ptr, screen);
 276    trace_dump_arg(ptr, surface);
 277
 278    screen->tex_surface_release(screen, psurface);
 279
 280    trace_dump_call_end();
 281 }
 282
 283
 284 static void *
 285 trace_screen_surface_map(struct pipe_screen *_screen,
 286                          struct pipe_surface *surface,
 287                          unsigned flags)
 288 {
 289    struct trace_screen *tr_scr = trace_screen(_screen);
 290    struct pipe_screen *screen = tr_scr->screen;
 291    void *map;
 292
 293    map = screen->surface_map(screen, surface, flags);
 294    if(map) {
 295       if(flags & PIPE_BUFFER_USAGE_CPU_WRITE) {
 296          assert(!hash_table_get(tr_scr->surface_maps, surface));
 297          hash_table_set(tr_scr->surface_maps, surface, map);
 298       }
 299    }
 300
 301    return map;
 302 }
 303
 304
 305 static void
 306 trace_screen_surface_unmap(struct pipe_screen *_screen,
 307                            struct pipe_surface *surface)
 308 {
 309    struct trace_screen *tr_scr = trace_screen(_screen);
 310    struct pipe_screen *screen = tr_scr->screen;
 311    const void *map;
 312
 313    map = hash_table_get(tr_scr->surface_maps, surface);
 314    if(map) {
 315       size_t size = surface->nblocksy * surface->stride;
 316
 317       trace_dump_call_begin("pipe_winsys", "surface_write");
 318
 319       trace_dump_arg(ptr, screen);
 320
 321       trace_dump_arg(ptr, surface);
 322
 323       trace_dump_arg_begin("data");
 324       trace_dump_bytes(map, size);
 325       trace_dump_arg_end();
 326
 327       trace_dump_arg_begin("stride");
 328       trace_dump_uint(surface->stride);
 329       trace_dump_arg_end();
 330
 331       trace_dump_arg_begin("size");
 332       trace_dump_uint(size);
 333       trace_dump_arg_end();
 334
 335       trace_dump_call_end();
 336
 337       hash_table_remove(tr_scr->surface_maps, surface);
 338    }
 339
 340    screen->surface_unmap(screen, surface);
 341 }
 342
 343
 344 static void
 345 trace_screen_destroy(struct pipe_screen *_screen)
 346 {
 347    struct trace_screen *tr_scr = trace_screen(_screen);
 348    struct pipe_screen *screen = tr_scr->screen;
 349
 350    trace_dump_call_begin("pipe_screen", "destroy");
 351
 352    trace_dump_arg(ptr, screen);
 353
 354    screen->destroy(screen);
 355
 356    trace_dump_call_end();
 357
 358    trace_dump_trace_end();
 359
 360    FREE(tr_scr);
 361 }
 362
 363
 364 struct pipe_screen *
 365 trace_screen_create(struct pipe_screen *screen)
 366 {
 367    struct trace_screen *tr_scr;
 368    struct pipe_winsys *winsys;
 369
 370    if(!screen)
 371       goto error1;
 372
 373    if(!trace_dump_trace_begin())
 374       goto error1;
 375
 376    tr_scr = CALLOC_STRUCT(trace_screen);
 377    if(!tr_scr)
 378       goto error2;
 379
 380    winsys = trace_winsys_create(screen->winsys);
 381    if(!winsys)
 382       goto error3;
 383
 384    tr_scr->base.winsys = winsys;
 385    tr_scr->base.destroy = trace_screen_destroy;
 386    tr_scr->base.get_name = trace_screen_get_name;
 387    tr_scr->base.get_vendor = trace_screen_get_vendor;
 388    tr_scr->base.get_param = trace_screen_get_param;
 389    tr_scr->base.get_paramf = trace_screen_get_paramf;
 390    tr_scr->base.is_format_supported = trace_screen_is_format_supported;
 391    tr_scr->base.texture_create = trace_screen_texture_create;
 392    tr_scr->base.texture_blanket = trace_screen_texture_blanket;
 393    tr_scr->base.texture_release = trace_screen_texture_release;
 394    tr_scr->base.get_tex_surface = trace_screen_get_tex_surface;
 395    tr_scr->base.tex_surface_release = trace_screen_tex_surface_release;
 396    tr_scr->base.surface_map = trace_screen_surface_map;
 397    tr_scr->base.surface_unmap = trace_screen_surface_unmap;
 398
 399    tr_scr->screen = screen;
 400
 401    tr_scr->surface_maps = hash_table_create(trace_surface_hash,
 402                                             trace_surface_compare);
 403    if(!tr_scr->surface_maps)
 404       goto error3;
 405
 406    trace_dump_call_begin("", "pipe_screen_create");
 407    trace_dump_arg_begin("winsys");
 408    trace_dump_ptr(screen->winsys);
 409    trace_dump_arg_end();
 410    trace_dump_ret(ptr, screen);
 411    trace_dump_call_end();
 412
 413    return &tr_scr->base;
 414
 415 error3:
 416    FREE(tr_scr);
 417 error2:
 418    trace_dump_trace_end();
 419 error1:
 420    return screen;
 421 }