1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 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 VMWARE 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/simple_list.h" 31 32 #include "tr_dump.h" 33 #include "tr_dump_defines.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 41 static boolean trace = FALSE; 42 43 static const char * 44 trace_screen_get_name(struct pipe_screen *_screen) 45 { 46 struct trace_screen *tr_scr = trace_screen(_screen); 47 struct pipe_screen *screen = tr_scr->screen; 48 const char *result; 49 50 trace_dump_call_begin("pipe_screen", "get_name"); 51 52 trace_dump_arg(ptr, screen); 53 54 result = screen->get_name(screen); 55 56 trace_dump_ret(string, result); 57 58 trace_dump_call_end(); 59 60 return result; 61 } 62 63 64 static const char * 65 trace_screen_get_vendor(struct pipe_screen *_screen) 66 { 67 struct trace_screen *tr_scr = trace_screen(_screen); 68 struct pipe_screen *screen = tr_scr->screen; 69 const char *result; 70 71 trace_dump_call_begin("pipe_screen", "get_vendor"); 72 73 trace_dump_arg(ptr, screen); 74 75 result = screen->get_vendor(screen); 76 77 trace_dump_ret(string, result); 78 79 trace_dump_call_end(); 80 81 return result; 82 } 83 84 85 static const char * 86 trace_screen_get_device_vendor(struct pipe_screen *_screen) 87 { 88 struct trace_screen *tr_scr = trace_screen(_screen); 89 struct pipe_screen *screen = tr_scr->screen; 90 const char *result; 91 92 trace_dump_call_begin("pipe_screen", "get_device_vendor"); 93 94 trace_dump_arg(ptr, screen); 95 96 result = screen->get_device_vendor(screen); 97 98 trace_dump_ret(string, result); 99 100 trace_dump_call_end(); 101 102 return result; 103 } 104 105 106 static int 107 trace_screen_get_param(struct pipe_screen *_screen, 108 enum pipe_cap param) 109 { 110 struct trace_screen *tr_scr = trace_screen(_screen); 111 struct pipe_screen *screen = tr_scr->screen; 112 int result; 113 114 trace_dump_call_begin("pipe_screen", "get_param"); 115 116 trace_dump_arg(ptr, screen); 117 trace_dump_arg(int, param); 118 119 result = screen->get_param(screen, param); 120 121 trace_dump_ret(int, result); 122 123 trace_dump_call_end(); 124 125 return result; 126 } 127 128 129 static int 130 trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader, 131 enum pipe_shader_cap param) 132 { 133 struct trace_screen *tr_scr = trace_screen(_screen); 134 struct pipe_screen *screen = tr_scr->screen; 135 int result; 136 137 trace_dump_call_begin("pipe_screen", "get_shader_param"); 138 139 trace_dump_arg(ptr, screen); 140 trace_dump_arg(uint, shader); 141 trace_dump_arg(int, param); 142 143 result = screen->get_shader_param(screen, shader, param); 144 145 trace_dump_ret(int, result); 146 147 trace_dump_call_end(); 148 149 return result; 150 } 151 152 153 static float 154 trace_screen_get_paramf(struct pipe_screen *_screen, 155 enum pipe_capf param) 156 { 157 struct trace_screen *tr_scr = trace_screen(_screen); 158 struct pipe_screen *screen = tr_scr->screen; 159 float result; 160 161 trace_dump_call_begin("pipe_screen", "get_paramf"); 162 163 trace_dump_arg(ptr, screen); 164 trace_dump_arg(int, param); 165 166 result = screen->get_paramf(screen, param); 167 168 trace_dump_ret(float, result); 169 170 trace_dump_call_end(); 171 172 return result; 173 } 174 175 176 static int 177 trace_screen_get_compute_param(struct pipe_screen *_screen, 178 enum pipe_shader_ir ir_type, 179 enum pipe_compute_cap param, void *data) 180 { 181 struct trace_screen *tr_scr = trace_screen(_screen); 182 struct pipe_screen *screen = tr_scr->screen; 183 int result; 184 185 trace_dump_call_begin("pipe_screen", "get_compute_param"); 186 187 trace_dump_arg(ptr, screen); 188 trace_dump_arg(int, ir_type); 189 trace_dump_arg(int, param); 190 trace_dump_arg(ptr, data); 191 192 result = screen->get_compute_param(screen, ir_type, param, data); 193 194 trace_dump_ret(int, result); 195 196 trace_dump_call_end(); 197 198 return result; 199 } 200 201 202 static boolean 203 trace_screen_is_format_supported(struct pipe_screen *_screen, 204 enum pipe_format format, 205 enum pipe_texture_target target, 206 unsigned sample_count, 207 unsigned tex_usage) 208 { 209 struct trace_screen *tr_scr = trace_screen(_screen); 210 struct pipe_screen *screen = tr_scr->screen; 211 boolean result; 212 213 trace_dump_call_begin("pipe_screen", "is_format_supported"); 214 215 trace_dump_arg(ptr, screen); 216 trace_dump_arg(format, format); 217 trace_dump_arg(int, target); 218 trace_dump_arg(uint, sample_count); 219 trace_dump_arg(uint, tex_usage); 220 221 result = screen->is_format_supported(screen, format, target, sample_count, 222 tex_usage); 223 224 trace_dump_ret(bool, result); 225 226 trace_dump_call_end(); 227 228 return result; 229 } 230 231 232 static struct pipe_context * 233 trace_screen_context_create(struct pipe_screen *_screen, void *priv, 234 unsigned flags) 235 { 236 struct trace_screen *tr_scr = trace_screen(_screen); 237 struct pipe_screen *screen = tr_scr->screen; 238 struct pipe_context *result; 239 240 trace_dump_call_begin("pipe_screen", "context_create"); 241 242 trace_dump_arg(ptr, screen); 243 trace_dump_arg(ptr, priv); 244 trace_dump_arg(uint, flags); 245 246 result = screen->context_create(screen, priv, flags); 247 248 trace_dump_ret(ptr, result); 249 250 trace_dump_call_end(); 251 252 result = trace_context_create(tr_scr, result); 253 254 return result; 255 } 256 257 258 static void 259 trace_screen_flush_frontbuffer(struct pipe_screen *_screen, 260 struct pipe_resource *_resource, 261 unsigned level, unsigned layer, 262 void *context_private, 263 struct pipe_box *sub_box) 264 { 265 struct trace_screen *tr_scr = trace_screen(_screen); 266 struct trace_resource *tr_res = trace_resource(_resource); 267 struct pipe_screen *screen = tr_scr->screen; 268 struct pipe_resource *resource = tr_res->resource; 269 270 trace_dump_call_begin("pipe_screen", "flush_frontbuffer"); 271 272 trace_dump_arg(ptr, screen); 273 trace_dump_arg(ptr, resource); 274 trace_dump_arg(uint, level); 275 trace_dump_arg(uint, layer); 276 /* XXX: hide, as there is nothing we can do with this 277 trace_dump_arg(ptr, context_private); 278 */ 279 280 screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box); 281 282 trace_dump_call_end(); 283 } 284 285 286 /******************************************************************** 287 * texture 288 */ 289 290 291 static struct pipe_resource * 292 trace_screen_resource_create(struct pipe_screen *_screen, 293 const struct pipe_resource *templat) 294 { 295 struct trace_screen *tr_scr = trace_screen(_screen); 296 struct pipe_screen *screen = tr_scr->screen; 297 struct pipe_resource *result; 298 299 trace_dump_call_begin("pipe_screen", "resource_create"); 300 301 trace_dump_arg(ptr, screen); 302 trace_dump_arg(resource_template, templat); 303 304 result = screen->resource_create(screen, templat); 305 306 trace_dump_ret(ptr, result); 307 308 trace_dump_call_end(); 309 310 result = trace_resource_create(tr_scr, result); 311 312 return result; 313 } 314 315 static struct pipe_resource * 316 trace_screen_resource_from_handle(struct pipe_screen *_screen, 317 const struct pipe_resource *templ, 318 struct winsys_handle *handle, 319 unsigned usage) 320 { 321 struct trace_screen *tr_screen = trace_screen(_screen); 322 struct pipe_screen *screen = tr_screen->screen; 323 struct pipe_resource *result; 324 325 /* TODO trace call */ 326 327 result = screen->resource_from_handle(screen, templ, handle, usage); 328 329 result = trace_resource_create(trace_screen(_screen), result); 330 331 return result; 332 } 333 334 static boolean 335 trace_screen_resource_get_handle(struct pipe_screen *_screen, 336 struct pipe_context *_pipe, 337 struct pipe_resource *_resource, 338 struct winsys_handle *handle, 339 unsigned usage) 340 { 341 struct trace_screen *tr_screen = trace_screen(_screen); 342 struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL; 343 struct trace_resource *tr_resource = trace_resource(_resource); 344 struct pipe_screen *screen = tr_screen->screen; 345 struct pipe_resource *resource = tr_resource->resource; 346 347 /* TODO trace call */ 348 349 return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL, 350 resource, handle, usage); 351 } 352 353 354 355 static void 356 trace_screen_resource_destroy(struct pipe_screen *_screen, 357 struct pipe_resource *_resource) 358 { 359 struct trace_screen *tr_scr = trace_screen(_screen); 360 struct trace_resource *tr_res = trace_resource(_resource); 361 struct pipe_screen *screen = tr_scr->screen; 362 struct pipe_resource *resource = tr_res->resource; 363 364 assert(resource->screen == screen); 365 366 trace_dump_call_begin("pipe_screen", "resource_destroy"); 367 368 trace_dump_arg(ptr, screen); 369 trace_dump_arg(ptr, resource); 370 371 trace_dump_call_end(); 372 373 trace_resource_destroy(tr_scr, tr_res); 374 } 375 376 377 /******************************************************************** 378 * fence 379 */ 380 381 382 static void 383 trace_screen_fence_reference(struct pipe_screen *_screen, 384 struct pipe_fence_handle **pdst, 385 struct pipe_fence_handle *src) 386 { 387 struct trace_screen *tr_scr = trace_screen(_screen); 388 struct pipe_screen *screen = tr_scr->screen; 389 struct pipe_fence_handle *dst; 390 391 assert(pdst); 392 dst = *pdst; 393 394 trace_dump_call_begin("pipe_screen", "fence_reference"); 395 396 trace_dump_arg(ptr, screen); 397 trace_dump_arg(ptr, dst); 398 trace_dump_arg(ptr, src); 399 400 screen->fence_reference(screen, pdst, src); 401 402 trace_dump_call_end(); 403 } 404 405 406 static boolean 407 trace_screen_fence_finish(struct pipe_screen *_screen, 408 struct pipe_context *_ctx, 409 struct pipe_fence_handle *fence, 410 uint64_t timeout) 411 { 412 struct trace_screen *tr_scr = trace_screen(_screen); 413 struct pipe_screen *screen = tr_scr->screen; 414 struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL; 415 int result; 416 417 trace_dump_call_begin("pipe_screen", "fence_finish"); 418 419 trace_dump_arg(ptr, screen); 420 trace_dump_arg(ptr, ctx); 421 trace_dump_arg(ptr, fence); 422 trace_dump_arg(uint, timeout); 423 424 result = screen->fence_finish(screen, ctx, fence, timeout); 425 426 trace_dump_ret(bool, result); 427 428 trace_dump_call_end(); 429 430 return result; 431 } 432 433 434 /******************************************************************** 435 * screen 436 */ 437 438 static uint64_t 439 trace_screen_get_timestamp(struct pipe_screen *_screen) 440 { 441 struct trace_screen *tr_scr = trace_screen(_screen); 442 struct pipe_screen *screen = tr_scr->screen; 443 uint64_t result; 444 445 trace_dump_call_begin("pipe_screen", "get_timestamp"); 446 trace_dump_arg(ptr, screen); 447 448 result = screen->get_timestamp(screen); 449 450 trace_dump_ret(uint, result); 451 trace_dump_call_end(); 452 453 return result; 454 } 455 456 static void 457 trace_screen_destroy(struct pipe_screen *_screen) 458 { 459 struct trace_screen *tr_scr = trace_screen(_screen); 460 struct pipe_screen *screen = tr_scr->screen; 461 462 trace_dump_call_begin("pipe_screen", "destroy"); 463 trace_dump_arg(ptr, screen); 464 trace_dump_call_end(); 465 466 screen->destroy(screen); 467 468 FREE(tr_scr); 469 } 470 471 boolean 472 trace_enabled(void) 473 { 474 static boolean firstrun = TRUE; 475 476 if (!firstrun) 477 return trace; 478 firstrun = FALSE; 479 480 if(trace_dump_trace_begin()) { 481 trace_dumping_start(); 482 trace = TRUE; 483 } 484 485 return trace; 486 } 487 488 struct pipe_screen * 489 trace_screen_create(struct pipe_screen *screen) 490 { 491 struct trace_screen *tr_scr; 492 493 if (!trace_enabled()) 494 goto error1; 495 496 trace_dump_call_begin("", "pipe_screen_create"); 497 498 tr_scr = CALLOC_STRUCT(trace_screen); 499 if (!tr_scr) 500 goto error2; 501 502 tr_scr->base.destroy = trace_screen_destroy; 503 tr_scr->base.get_name = trace_screen_get_name; 504 tr_scr->base.get_vendor = trace_screen_get_vendor; 505 tr_scr->base.get_device_vendor = trace_screen_get_device_vendor; 506 tr_scr->base.get_param = trace_screen_get_param; 507 tr_scr->base.get_shader_param = trace_screen_get_shader_param; 508 tr_scr->base.get_paramf = trace_screen_get_paramf; 509 tr_scr->base.get_compute_param = trace_screen_get_compute_param; 510 tr_scr->base.is_format_supported = trace_screen_is_format_supported; 511 assert(screen->context_create); 512 tr_scr->base.context_create = trace_screen_context_create; 513 tr_scr->base.resource_create = trace_screen_resource_create; 514 tr_scr->base.resource_from_handle = trace_screen_resource_from_handle; 515 tr_scr->base.resource_get_handle = trace_screen_resource_get_handle; 516 tr_scr->base.resource_destroy = trace_screen_resource_destroy; 517 tr_scr->base.fence_reference = trace_screen_fence_reference; 518 tr_scr->base.fence_finish = trace_screen_fence_finish; 519 tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer; 520 tr_scr->base.get_timestamp = trace_screen_get_timestamp; 521 522 tr_scr->screen = screen; 523 524 trace_dump_ret(ptr, screen); 525 trace_dump_call_end(); 526 527 return &tr_scr->base; 528 529 error2: 530 trace_dump_ret(ptr, screen); 531 trace_dump_call_end(); 532 error1: 533 return screen; 534 } 535 536 537 struct trace_screen * 538 trace_screen(struct pipe_screen *screen) 539 { 540 assert(screen); 541 assert(screen->destroy == trace_screen_destroy); 542 return (struct trace_screen *)screen; 543 } 544
