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