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 29 #include "pipe/p_compiler.h" 30 #include "util/u_memory.h" 31 #include "util/u_format.h" 32 #include "tgsi/tgsi_dump.h" 33 34 #include "tr_dump.h" 35 #include "tr_dump_state.h" 36 37 38 void trace_dump_format(enum pipe_format format) 39 { 40 if (!trace_dumping_enabled_locked()) 41 return; 42 43 trace_dump_enum(util_format_name(format) ); 44 } 45 46 47 void trace_dump_resource_template(const struct pipe_resource *templat) 48 { 49 if (!trace_dumping_enabled_locked()) 50 return; 51 52 if(!templat) { 53 trace_dump_null(); 54 return; 55 } 56 57 trace_dump_struct_begin("pipe_resource"); 58 59 trace_dump_member(int, templat, target); 60 trace_dump_member(format, templat, format); 61 62 trace_dump_member_begin("width"); 63 trace_dump_uint(templat->width0); 64 trace_dump_member_end(); 65 66 trace_dump_member_begin("height"); 67 trace_dump_uint(templat->height0); 68 trace_dump_member_end(); 69 70 trace_dump_member_begin("depth"); 71 trace_dump_uint(templat->depth0); 72 trace_dump_member_end(); 73 74 trace_dump_member_begin("array_size"); 75 trace_dump_uint(templat->array_size); 76 trace_dump_member_end(); 77 78 trace_dump_member(uint, templat, last_level); 79 trace_dump_member(uint, templat, usage); 80 trace_dump_member(uint, templat, bind); 81 trace_dump_member(uint, templat, flags); 82 83 trace_dump_struct_end(); 84 } 85 86 87 void trace_dump_box(const struct pipe_box *box) 88 { 89 if (!trace_dumping_enabled_locked()) 90 return; 91 92 if(!box) { 93 trace_dump_null(); 94 return; 95 } 96 97 trace_dump_struct_begin("pipe_box"); 98 99 trace_dump_member(uint, box, x); 100 trace_dump_member(uint, box, y); 101 trace_dump_member(uint, box, z); 102 trace_dump_member(uint, box, width); 103 trace_dump_member(uint, box, height); 104 trace_dump_member(uint, box, depth); 105 106 trace_dump_struct_end(); 107 } 108 109 110 void trace_dump_rasterizer_state(const struct pipe_rasterizer_state *state) 111 { 112 if (!trace_dumping_enabled_locked()) 113 return; 114 115 if(!state) { 116 trace_dump_null(); 117 return; 118 } 119 120 trace_dump_struct_begin("pipe_rasterizer_state"); 121 122 trace_dump_member(bool, state, flatshade); 123 trace_dump_member(bool, state, light_twoside); 124 trace_dump_member(bool, state, clamp_vertex_color); 125 trace_dump_member(bool, state, clamp_fragment_color); 126 trace_dump_member(uint, state, front_ccw); 127 trace_dump_member(uint, state, cull_face); 128 trace_dump_member(uint, state, fill_front); 129 trace_dump_member(uint, state, fill_back); 130 trace_dump_member(bool, state, offset_point); 131 trace_dump_member(bool, state, offset_line); 132 trace_dump_member(bool, state, offset_tri); 133 trace_dump_member(bool, state, scissor); 134 trace_dump_member(bool, state, poly_smooth); 135 trace_dump_member(bool, state, poly_stipple_enable); 136 trace_dump_member(bool, state, point_smooth); 137 trace_dump_member(uint, state, sprite_coord_enable); 138 trace_dump_member(bool, state, sprite_coord_mode); 139 trace_dump_member(bool, state, point_quad_rasterization); 140 trace_dump_member(bool, state, point_size_per_vertex); 141 trace_dump_member(bool, state, multisample); 142 trace_dump_member(bool, state, line_smooth); 143 trace_dump_member(bool, state, line_stipple_enable); 144 trace_dump_member(uint, state, line_stipple_factor); 145 trace_dump_member(uint, state, line_stipple_pattern); 146 trace_dump_member(bool, state, line_last_pixel); 147 trace_dump_member(bool, state, flatshade_first); 148 trace_dump_member(bool, state, gl_rasterization_rules); 149 trace_dump_member(bool, state, rasterizer_discard); 150 trace_dump_member(bool, state, depth_clip); 151 trace_dump_member(uint, state, clip_plane_enable); 152 153 trace_dump_member(float, state, line_width); 154 trace_dump_member(float, state, point_size); 155 trace_dump_member(float, state, offset_units); 156 trace_dump_member(float, state, offset_scale); 157 trace_dump_member(float, state, offset_clamp); 158 159 trace_dump_struct_end(); 160 } 161 162 163 void trace_dump_poly_stipple(const struct pipe_poly_stipple *state) 164 { 165 if (!trace_dumping_enabled_locked()) 166 return; 167 168 if(!state) { 169 trace_dump_null(); 170 return; 171 } 172 173 trace_dump_struct_begin("pipe_poly_stipple"); 174 175 trace_dump_member_begin("stipple"); 176 trace_dump_array(uint, 177 state->stipple, 178 Elements(state->stipple)); 179 trace_dump_member_end(); 180 181 trace_dump_struct_end(); 182 } 183 184 185 void trace_dump_viewport_state(const struct pipe_viewport_state *state) 186 { 187 if (!trace_dumping_enabled_locked()) 188 return; 189 190 if(!state) { 191 trace_dump_null(); 192 return; 193 } 194 195 trace_dump_struct_begin("pipe_viewport_state"); 196 197 trace_dump_member_array(float, state, scale); 198 trace_dump_member_array(float, state, translate); 199 200 trace_dump_struct_end(); 201 } 202 203 204 void trace_dump_scissor_state(const struct pipe_scissor_state *state) 205 { 206 if (!trace_dumping_enabled_locked()) 207 return; 208 209 if(!state) { 210 trace_dump_null(); 211 return; 212 } 213 214 trace_dump_struct_begin("pipe_scissor_state"); 215 216 trace_dump_member(uint, state, minx); 217 trace_dump_member(uint, state, miny); 218 trace_dump_member(uint, state, maxx); 219 trace_dump_member(uint, state, maxy); 220 221 trace_dump_struct_end(); 222 } 223 224 225 void trace_dump_clip_state(const struct pipe_clip_state *state) 226 { 227 unsigned i; 228 229 if (!trace_dumping_enabled_locked()) 230 return; 231 232 if(!state) { 233 trace_dump_null(); 234 return; 235 } 236 237 trace_dump_struct_begin("pipe_clip_state"); 238 239 trace_dump_member_begin("ucp"); 240 trace_dump_array_begin(); 241 for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) { 242 trace_dump_elem_begin(); 243 trace_dump_array(float, state->ucp[i], 4); 244 trace_dump_elem_end(); 245 } 246 trace_dump_array_end(); 247 trace_dump_member_end(); 248 249 trace_dump_struct_end(); 250 } 251 252 253 void trace_dump_shader_state(const struct pipe_shader_state *state) 254 { 255 static char str[8192]; 256 unsigned i; 257 258 if (!trace_dumping_enabled_locked()) 259 return; 260 261 if(!state) { 262 trace_dump_null(); 263 return; 264 } 265 266 tgsi_dump_str(state->tokens, 0, str, sizeof(str)); 267 268 trace_dump_struct_begin("pipe_shader_state"); 269 270 trace_dump_member_begin("tokens"); 271 trace_dump_string(str); 272 trace_dump_member_end(); 273 274 trace_dump_member_begin("stream_output"); 275 trace_dump_struct_begin("pipe_stream_output_info"); 276 trace_dump_member(uint, &state->stream_output, num_outputs); 277 trace_dump_member_array(uint, &state->stream_output, stride); 278 trace_dump_member_begin("output"); 279 trace_dump_array_begin(); 280 for(i = 0; i < state->stream_output.num_outputs; ++i) { 281 trace_dump_elem_begin(); 282 trace_dump_struct_begin(""); /* anonymous */ 283 trace_dump_member(uint, &state->stream_output.output[i], register_index); 284 trace_dump_member(uint, &state->stream_output.output[i], start_component); 285 trace_dump_member(uint, &state->stream_output.output[i], num_components); 286 trace_dump_member(uint, &state->stream_output.output[i], output_buffer); 287 trace_dump_member(uint, &state->stream_output.output[i], dst_offset); 288 trace_dump_struct_end(); 289 trace_dump_elem_end(); 290 } 291 trace_dump_array_end(); 292 trace_dump_member_end(); // output 293 trace_dump_struct_end(); 294 trace_dump_member_end(); // stream_output 295 296 trace_dump_struct_end(); 297 } 298 299 300 void trace_dump_depth_stencil_alpha_state(const struct pipe_depth_stencil_alpha_state *state) 301 { 302 unsigned i; 303 304 if (!trace_dumping_enabled_locked()) 305 return; 306 307 if(!state) { 308 trace_dump_null(); 309 return; 310 } 311 312 trace_dump_struct_begin("pipe_depth_stencil_alpha_state"); 313 314 trace_dump_member_begin("depth"); 315 trace_dump_struct_begin("pipe_depth_state"); 316 trace_dump_member(bool, &state->depth, enabled); 317 trace_dump_member(bool, &state->depth, writemask); 318 trace_dump_member(uint, &state->depth, func); 319 trace_dump_struct_end(); 320 trace_dump_member_end(); 321 322 trace_dump_member_begin("stencil"); 323 trace_dump_array_begin(); 324 for(i = 0; i < Elements(state->stencil); ++i) { 325 trace_dump_elem_begin(); 326 trace_dump_struct_begin("pipe_stencil_state"); 327 trace_dump_member(bool, &state->stencil[i], enabled); 328 trace_dump_member(uint, &state->stencil[i], func); 329 trace_dump_member(uint, &state->stencil[i], fail_op); 330 trace_dump_member(uint, &state->stencil[i], zpass_op); 331 trace_dump_member(uint, &state->stencil[i], zfail_op); 332 trace_dump_member(uint, &state->stencil[i], valuemask); 333 trace_dump_member(uint, &state->stencil[i], writemask); 334 trace_dump_struct_end(); 335 trace_dump_elem_end(); 336 } 337 trace_dump_array_end(); 338 trace_dump_member_end(); 339 340 trace_dump_member_begin("alpha"); 341 trace_dump_struct_begin("pipe_alpha_state"); 342 trace_dump_member(bool, &state->alpha, enabled); 343 trace_dump_member(uint, &state->alpha, func); 344 trace_dump_member(float, &state->alpha, ref_value); 345 trace_dump_struct_end(); 346 trace_dump_member_end(); 347 348 trace_dump_struct_end(); 349 } 350 351 static void trace_dump_rt_blend_state(const struct pipe_rt_blend_state *state) 352 { 353 trace_dump_struct_begin("pipe_rt_blend_state"); 354 355 trace_dump_member(uint, state, blend_enable); 356 357 trace_dump_member(uint, state, rgb_func); 358 trace_dump_member(uint, state, rgb_src_factor); 359 trace_dump_member(uint, state, rgb_dst_factor); 360 361 trace_dump_member(uint, state, alpha_func); 362 trace_dump_member(uint, state, alpha_src_factor); 363 trace_dump_member(uint, state, alpha_dst_factor); 364 365 trace_dump_member(uint, state, colormask); 366 367 trace_dump_struct_end(); 368 } 369 370 void trace_dump_blend_state(const struct pipe_blend_state *state) 371 { 372 unsigned valid_entries = 1; 373 374 if (!trace_dumping_enabled_locked()) 375 return; 376 377 if(!state) { 378 trace_dump_null(); 379 return; 380 } 381 382 trace_dump_struct_begin("pipe_blend_state"); 383 384 trace_dump_member(bool, state, dither); 385 386 trace_dump_member(bool, state, logicop_enable); 387 trace_dump_member(uint, state, logicop_func); 388 389 trace_dump_member(bool, state, independent_blend_enable); 390 391 trace_dump_member_begin("rt"); 392 if (state->independent_blend_enable) 393 valid_entries = PIPE_MAX_COLOR_BUFS; 394 trace_dump_struct_array(rt_blend_state, state->rt, valid_entries); 395 trace_dump_member_end(); 396 397 trace_dump_struct_end(); 398 } 399 400 401 void trace_dump_blend_color(const struct pipe_blend_color *state) 402 { 403 if (!trace_dumping_enabled_locked()) 404 return; 405 406 if(!state) { 407 trace_dump_null(); 408 return; 409 } 410 411 trace_dump_struct_begin("pipe_blend_color"); 412 413 trace_dump_member_array(float, state, color); 414 415 trace_dump_struct_end(); 416 } 417 418 void trace_dump_stencil_ref(const struct pipe_stencil_ref *state) 419 { 420 if (!trace_dumping_enabled_locked()) 421 return; 422 423 if(!state) { 424 trace_dump_null(); 425 return; 426 } 427 428 trace_dump_struct_begin("pipe_stencil_ref"); 429 430 trace_dump_member_array(uint, state, ref_value); 431 432 trace_dump_struct_end(); 433 } 434 435 void trace_dump_framebuffer_state(const struct pipe_framebuffer_state *state) 436 { 437 if (!trace_dumping_enabled_locked()) 438 return; 439 440 trace_dump_struct_begin("pipe_framebuffer_state"); 441 442 trace_dump_member(uint, state, width); 443 trace_dump_member(uint, state, height); 444 trace_dump_member(uint, state, nr_cbufs); 445 trace_dump_member_array(ptr, state, cbufs); 446 trace_dump_member(ptr, state, zsbuf); 447 448 trace_dump_struct_end(); 449 } 450 451 452 void trace_dump_sampler_state(const struct pipe_sampler_state *state) 453 { 454 if (!trace_dumping_enabled_locked()) 455 return; 456 457 if(!state) { 458 trace_dump_null(); 459 return; 460 } 461 462 trace_dump_struct_begin("pipe_sampler_state"); 463 464 trace_dump_member(uint, state, wrap_s); 465 trace_dump_member(uint, state, wrap_t); 466 trace_dump_member(uint, state, wrap_r); 467 trace_dump_member(uint, state, min_img_filter); 468 trace_dump_member(uint, state, min_mip_filter); 469 trace_dump_member(uint, state, mag_img_filter); 470 trace_dump_member(uint, state, compare_mode); 471 trace_dump_member(uint, state, compare_func); 472 trace_dump_member(bool, state, normalized_coords); 473 trace_dump_member(uint, state, max_anisotropy); 474 trace_dump_member(float, state, lod_bias); 475 trace_dump_member(float, state, min_lod); 476 trace_dump_member(float, state, max_lod); 477 trace_dump_member_array(float, state, border_color.f); 478 479 trace_dump_struct_end(); 480 } 481 482 483 void trace_dump_sampler_view_template(const struct pipe_sampler_view *state, 484 enum pipe_texture_target target) 485 { 486 if (!trace_dumping_enabled_locked()) 487 return; 488 489 if(!state) { 490 trace_dump_null(); 491 return; 492 } 493 494 trace_dump_struct_begin("pipe_sampler_view"); 495 496 trace_dump_member(format, state, format); 497 498 trace_dump_member_begin("u"); 499 trace_dump_struct_begin(""); /* anonymous */ 500 if (target == PIPE_BUFFER) { 501 trace_dump_member_begin("buf"); 502 trace_dump_struct_begin(""); /* anonymous */ 503 trace_dump_member(uint, &state->u.buf, first_element); 504 trace_dump_member(uint, &state->u.buf, last_element); 505 trace_dump_struct_end(); /* anonymous */ 506 trace_dump_member_end(); /* buf */ 507 } else { 508 trace_dump_member_begin("tex"); 509 trace_dump_struct_begin(""); /* anonymous */ 510 trace_dump_member(uint, &state->u.tex, first_layer); 511 trace_dump_member(uint, &state->u.tex, last_layer); 512 trace_dump_member(uint, &state->u.tex, first_level); 513 trace_dump_member(uint, &state->u.tex, last_level); 514 trace_dump_struct_end(); /* anonymous */ 515 trace_dump_member_end(); /* tex */ 516 } 517 trace_dump_struct_end(); /* anonymous */ 518 trace_dump_member_end(); /* u */ 519 520 trace_dump_member(uint, state, swizzle_r); 521 trace_dump_member(uint, state, swizzle_g); 522 trace_dump_member(uint, state, swizzle_b); 523 trace_dump_member(uint, state, swizzle_a); 524 525 trace_dump_struct_end(); 526 } 527 528 529 void trace_dump_surface_template(const struct pipe_surface *state, 530 enum pipe_texture_target target) 531 { 532 if (!trace_dumping_enabled_locked()) 533 return; 534 535 if(!state) { 536 trace_dump_null(); 537 return; 538 } 539 540 trace_dump_struct_begin("pipe_surface"); 541 542 trace_dump_member(format, state, format); 543 trace_dump_member(uint, state, width); 544 trace_dump_member(uint, state, height); 545 546 trace_dump_member(uint, state, usage); 547 548 trace_dump_member_begin("u"); 549 trace_dump_struct_begin(""); /* anonymous */ 550 if (target == PIPE_BUFFER) { 551 trace_dump_member_begin("buf"); 552 trace_dump_struct_begin(""); /* anonymous */ 553 trace_dump_member(uint, &state->u.buf, first_element); 554 trace_dump_member(uint, &state->u.buf, last_element); 555 trace_dump_struct_end(); /* anonymous */ 556 trace_dump_member_end(); /* buf */ 557 } else { 558 trace_dump_member_begin("tex"); 559 trace_dump_struct_begin(""); /* anonymous */ 560 trace_dump_member(uint, &state->u.tex, level); 561 trace_dump_member(uint, &state->u.tex, first_layer); 562 trace_dump_member(uint, &state->u.tex, last_layer); 563 trace_dump_struct_end(); /* anonymous */ 564 trace_dump_member_end(); /* tex */ 565 } 566 trace_dump_struct_end(); /* anonymous */ 567 trace_dump_member_end(); /* u */ 568 569 trace_dump_struct_end(); 570 } 571 572 573 void trace_dump_transfer(const struct pipe_transfer *state) 574 { 575 if (!trace_dumping_enabled_locked()) 576 return; 577 578 if(!state) { 579 trace_dump_null(); 580 return; 581 } 582 583 trace_dump_struct_begin("pipe_transfer"); 584 585 trace_dump_member(uint, state, box.x); 586 trace_dump_member(uint, state, box.y); 587 trace_dump_member(uint, state, box.z); 588 trace_dump_member(uint, state, box.width); 589 trace_dump_member(uint, state, box.height); 590 trace_dump_member(uint, state, box.depth); 591 592 trace_dump_member(uint, state, stride); 593 trace_dump_member(uint, state, layer_stride); 594 trace_dump_member(uint, state, usage); 595 596 trace_dump_member(ptr, state, resource); 597 598 trace_dump_struct_end(); 599 } 600 601 602 void trace_dump_vertex_buffer(const struct pipe_vertex_buffer *state) 603 { 604 if (!trace_dumping_enabled_locked()) 605 return; 606 607 if(!state) { 608 trace_dump_null(); 609 return; 610 } 611 612 trace_dump_struct_begin("pipe_vertex_buffer"); 613 614 trace_dump_member(uint, state, stride); 615 trace_dump_member(uint, state, buffer_offset); 616 trace_dump_member(resource_ptr, state, buffer); 617 618 trace_dump_struct_end(); 619 } 620 621 622 void trace_dump_index_buffer(const struct pipe_index_buffer *state) 623 { 624 if (!trace_dumping_enabled_locked()) 625 return; 626 627 if(!state) { 628 trace_dump_null(); 629 return; 630 } 631 632 trace_dump_struct_begin("pipe_index_buffer"); 633 634 trace_dump_member(uint, state, index_size); 635 trace_dump_member(uint, state, offset); 636 trace_dump_member(resource_ptr, state, buffer); 637 638 trace_dump_struct_end(); 639 } 640 641 642 void trace_dump_vertex_element(const struct pipe_vertex_element *state) 643 { 644 if (!trace_dumping_enabled_locked()) 645 return; 646 647 if(!state) { 648 trace_dump_null(); 649 return; 650 } 651 652 trace_dump_struct_begin("pipe_vertex_element"); 653 654 trace_dump_member(uint, state, src_offset); 655 656 trace_dump_member(uint, state, vertex_buffer_index); 657 658 trace_dump_member(format, state, src_format); 659 660 trace_dump_struct_end(); 661 } 662 663 664 void trace_dump_draw_info(const struct pipe_draw_info *state) 665 { 666 if (!trace_dumping_enabled_locked()) 667 return; 668 669 if(!state) { 670 trace_dump_null(); 671 return; 672 } 673 674 trace_dump_struct_begin("pipe_draw_info"); 675 676 trace_dump_member(bool, state, indexed); 677 678 trace_dump_member(uint, state, mode); 679 trace_dump_member(uint, state, start); 680 trace_dump_member(uint, state, count); 681 682 trace_dump_member(uint, state, start_instance); 683 trace_dump_member(uint, state, instance_count); 684 685 trace_dump_member(int, state, index_bias); 686 trace_dump_member(uint, state, min_index); 687 trace_dump_member(uint, state, max_index); 688 689 trace_dump_member(bool, state, primitive_restart); 690 trace_dump_member(uint, state, restart_index); 691 692 trace_dump_member(ptr, state, count_from_stream_output); 693 694 trace_dump_struct_end(); 695 } 696
