u_dump_state.c revision 861a029ddb31e91bb4d8e18ab708d0d172f63aad
1/************************************************************************** 2 * 3 * Copyright 2008-2010 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 29#include "pipe/p_compiler.h" 30#include "util/u_memory.h" 31#include "util/u_string.h" 32#include "util/u_format.h" 33#include "tgsi/tgsi_dump.h" 34 35#include "u_dump.h" 36 37 38/* 39 * Dump primitives 40 */ 41 42static INLINE void 43util_stream_writef(FILE *stream, const char *format, ...) 44{ 45 static char buf[1024]; 46 unsigned len; 47 va_list ap; 48 va_start(ap, format); 49 len = util_vsnprintf(buf, sizeof(buf), format, ap); 50 va_end(ap); 51 fwrite(buf, len, 1, stream); 52} 53 54static void 55util_dump_bool(FILE *stream, int value) 56{ 57 util_stream_writef(stream, "%c", value ? '1' : '0'); 58} 59 60static void 61util_dump_int(FILE *stream, long long int value) 62{ 63 util_stream_writef(stream, "%lli", value); 64} 65 66static void 67util_dump_uint(FILE *stream, long long unsigned value) 68{ 69 util_stream_writef(stream, "%llu", value); 70} 71 72static void 73util_dump_float(FILE *stream, double value) 74{ 75 util_stream_writef(stream, "%g", value); 76} 77 78static void 79util_dump_string(FILE *stream, const char *str) 80{ 81 fputs("\"", stream); 82 fputs(str, stream); 83 fputs("\"", stream); 84} 85 86static void 87util_dump_enum(FILE *stream, const char *value) 88{ 89 fputs(value, stream); 90} 91 92static void 93util_dump_array_begin(FILE *stream) 94{ 95 fputs("{", stream); 96} 97 98static void 99util_dump_array_end(FILE *stream) 100{ 101 fputs("}", stream); 102} 103 104static void 105util_dump_elem_begin(FILE *stream) 106{ 107} 108 109static void 110util_dump_elem_end(FILE *stream) 111{ 112 fputs(", ", stream); 113} 114 115static void 116util_dump_struct_begin(FILE *stream, const char *name) 117{ 118 fputs("{", stream); 119} 120 121static void 122util_dump_struct_end(FILE *stream) 123{ 124 fputs("}", stream); 125} 126 127static void 128util_dump_member_begin(FILE *stream, const char *name) 129{ 130 util_stream_writef(stream, "%s = ", name); 131} 132 133static void 134util_dump_member_end(FILE *stream) 135{ 136 fputs(", ", stream); 137} 138 139static void 140util_dump_null(FILE *stream) 141{ 142 fputs("NULL", stream); 143} 144 145static void 146util_dump_ptr(FILE *stream, const void *value) 147{ 148 if(value) 149 util_stream_writef(stream, "0x%08lx", (unsigned long)(uintptr_t)value); 150 else 151 util_dump_null(stream); 152} 153 154 155/* 156 * Code saving macros. 157 */ 158 159#define util_dump_arg(_stream, _type, _arg) \ 160 do { \ 161 util_dump_arg_begin(_stream, #_arg); \ 162 util_dump_##_type(_stream, _arg); \ 163 util_dump_arg_end(_stream); \ 164 } while(0) 165 166#define util_dump_ret(_stream, _type, _arg) \ 167 do { \ 168 util_dump_ret_begin(_stream); \ 169 util_dump_##_type(_stream, _arg); \ 170 util_dump_ret_end(_stream); \ 171 } while(0) 172 173#define util_dump_array(_stream, _type, _obj, _size) \ 174 do { \ 175 size_t idx; \ 176 util_dump_array_begin(_stream); \ 177 for(idx = 0; idx < (_size); ++idx) { \ 178 util_dump_elem_begin(_stream); \ 179 util_dump_##_type(_stream, (_obj)[idx]); \ 180 util_dump_elem_end(_stream); \ 181 } \ 182 util_dump_array_end(_stream); \ 183 } while(0) 184 185#define util_dump_struct_array(_stream, _type, _obj, _size) \ 186 do { \ 187 size_t idx; \ 188 util_dump_array_begin(_stream); \ 189 for(idx = 0; idx < (_size); ++idx) { \ 190 util_dump_elem_begin(_stream); \ 191 util_dump_##_type(_stream, &(_obj)[idx]); \ 192 util_dump_elem_end(_stream); \ 193 } \ 194 util_dump_array_end(_stream); \ 195 } while(0) 196 197#define util_dump_member(_stream, _type, _obj, _member) \ 198 do { \ 199 util_dump_member_begin(_stream, #_member); \ 200 util_dump_##_type(_stream, (_obj)->_member); \ 201 util_dump_member_end(_stream); \ 202 } while(0) 203 204#define util_dump_arg_array(_stream, _type, _arg, _size) \ 205 do { \ 206 util_dump_arg_begin(_stream, #_arg); \ 207 util_dump_array(_stream, _type, _arg, _size); \ 208 util_dump_arg_end(_stream); \ 209 } while(0) 210 211#define util_dump_member_array(_stream, _type, _obj, _member) \ 212 do { \ 213 util_dump_member_begin(_stream, #_member); \ 214 util_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \ 215 util_dump_member_end(_stream); \ 216 } while(0) 217 218 219 220/* 221 * Wrappers for enum -> string dumpers. 222 */ 223 224 225static void 226util_dump_format(FILE *stream, enum pipe_format format) 227{ 228 util_dump_enum(stream, util_format_name(format)); 229} 230 231 232static void 233util_dump_enum_blend_factor(FILE *stream, unsigned value) 234{ 235 util_dump_enum(stream, util_dump_blend_factor(value, TRUE)); 236} 237 238static void 239util_dump_enum_blend_func(FILE *stream, unsigned value) 240{ 241 util_dump_enum(stream, util_dump_blend_func(value, TRUE)); 242} 243 244static void 245util_dump_enum_func(FILE *stream, unsigned value) 246{ 247 util_dump_enum(stream, util_dump_func(value, TRUE)); 248} 249 250 251/* 252 * Public functions 253 */ 254 255 256void 257util_dump_template(FILE *stream, const struct pipe_resource *templat) 258{ 259 if(!templat) { 260 util_dump_null(stream); 261 return; 262 } 263 264 util_dump_struct_begin(stream, "pipe_resource"); 265 266 util_dump_member(stream, int, templat, target); 267 util_dump_member(stream, format, templat, format); 268 269 util_dump_member_begin(stream, "width"); 270 util_dump_uint(stream, templat->width0); 271 util_dump_member_end(stream); 272 273 util_dump_member_begin(stream, "height"); 274 util_dump_uint(stream, templat->height0); 275 util_dump_member_end(stream); 276 277 util_dump_member_begin(stream, "depth"); 278 util_dump_uint(stream, templat->depth0); 279 util_dump_member_end(stream); 280 281 util_dump_member_begin(stream, "array_size"); 282 util_dump_uint(stream, templat->array_size); 283 util_dump_member_end(stream); 284 285 util_dump_member(stream, uint, templat, last_level); 286 util_dump_member(stream, uint, templat, usage); 287 util_dump_member(stream, uint, templat, bind); 288 util_dump_member(stream, uint, templat, flags); 289 290 util_dump_struct_end(stream); 291} 292 293 294void 295util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *state) 296{ 297 if(!state) { 298 util_dump_null(stream); 299 return; 300 } 301 302 util_dump_struct_begin(stream, "pipe_rasterizer_state"); 303 304 util_dump_member(stream, bool, state, flatshade); 305 util_dump_member(stream, bool, state, light_twoside); 306 util_dump_member(stream, uint, state, front_ccw); 307 util_dump_member(stream, uint, state, cull_face); 308 util_dump_member(stream, uint, state, fill_front); 309 util_dump_member(stream, uint, state, fill_back); 310 util_dump_member(stream, bool, state, offset_point); 311 util_dump_member(stream, bool, state, offset_line); 312 util_dump_member(stream, bool, state, offset_tri); 313 util_dump_member(stream, bool, state, scissor); 314 util_dump_member(stream, bool, state, poly_smooth); 315 util_dump_member(stream, bool, state, poly_stipple_enable); 316 util_dump_member(stream, bool, state, point_smooth); 317 util_dump_member(stream, uint, state, sprite_coord_enable); 318 util_dump_member(stream, bool, state, sprite_coord_mode); 319 util_dump_member(stream, bool, state, point_quad_rasterization); 320 util_dump_member(stream, bool, state, point_size_per_vertex); 321 util_dump_member(stream, bool, state, multisample); 322 util_dump_member(stream, bool, state, line_smooth); 323 util_dump_member(stream, bool, state, line_stipple_enable); 324 util_dump_member(stream, uint, state, line_stipple_factor); 325 util_dump_member(stream, uint, state, line_stipple_pattern); 326 util_dump_member(stream, bool, state, line_last_pixel); 327 util_dump_member(stream, bool, state, flatshade_first); 328 util_dump_member(stream, bool, state, gl_rasterization_rules); 329 330 util_dump_member(stream, float, state, line_width); 331 util_dump_member(stream, float, state, point_size); 332 util_dump_member(stream, float, state, offset_units); 333 util_dump_member(stream, float, state, offset_scale); 334 util_dump_member(stream, float, state, offset_clamp); 335 336 util_dump_struct_end(stream); 337} 338 339 340void 341util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state) 342{ 343 if(!state) { 344 util_dump_null(stream); 345 return; 346 } 347 348 util_dump_struct_begin(stream, "pipe_poly_stipple"); 349 350 util_dump_member_begin(stream, "stipple"); 351 util_dump_member_array(stream, uint, state, stipple); 352 util_dump_member_end(stream); 353 354 util_dump_struct_end(stream); 355} 356 357 358void 359util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state) 360{ 361 if(!state) { 362 util_dump_null(stream); 363 return; 364 } 365 366 util_dump_struct_begin(stream, "pipe_viewport_state"); 367 368 util_dump_member_array(stream, float, state, scale); 369 util_dump_member_array(stream, float, state, translate); 370 371 util_dump_struct_end(stream); 372} 373 374 375void 376util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state) 377{ 378 if(!state) { 379 util_dump_null(stream); 380 return; 381 } 382 383 util_dump_struct_begin(stream, "pipe_scissor_state"); 384 385 util_dump_member(stream, uint, state, minx); 386 util_dump_member(stream, uint, state, miny); 387 util_dump_member(stream, uint, state, maxx); 388 util_dump_member(stream, uint, state, maxy); 389 390 util_dump_struct_end(stream); 391} 392 393 394void 395util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state) 396{ 397 unsigned i; 398 399 if(!state) { 400 util_dump_null(stream); 401 return; 402 } 403 404 util_dump_struct_begin(stream, "pipe_clip_state"); 405 406 util_dump_member_begin(stream, "ucp"); 407 util_dump_array_begin(stream); 408 for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) { 409 util_dump_elem_begin(stream); 410 util_dump_array(stream, float, state->ucp[i], 4); 411 util_dump_elem_end(stream); 412 } 413 util_dump_array_end(stream); 414 util_dump_member_end(stream); 415 416 util_dump_member(stream, uint, state, nr); 417 418 util_dump_struct_end(stream); 419} 420 421 422void 423util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state) 424{ 425 char str[8192]; 426 unsigned i; 427 428 if(!state) { 429 util_dump_null(stream); 430 return; 431 } 432 433 tgsi_dump_str(state->tokens, 0, str, sizeof(str)); 434 435 util_dump_struct_begin(stream, "pipe_shader_state"); 436 437 util_dump_member_begin(stream, "tokens"); 438 util_dump_string(stream, str); 439 util_dump_member_end(stream); 440 441 util_dump_member_begin(stream, "stream_output"); 442 util_dump_struct_begin(stream, "pipe_stream_output_info"); 443 util_dump_member(stream, uint, &state->stream_output, num_outputs); 444 util_dump_member(stream, uint, &state->stream_output, stride); 445 util_dump_array_begin(stream); 446 for(i = 0; i < state->stream_output.num_outputs; ++i) { 447 util_dump_elem_begin(stream); 448 util_dump_struct_begin(stream, ""); /* anonymous */ 449 util_dump_member(stream, uint, &state->stream_output.output[i], register_index); 450 util_dump_member(stream, uint, &state->stream_output.output[i], register_mask); 451 util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer); 452 util_dump_struct_end(stream); 453 util_dump_elem_end(stream); 454 } 455 util_dump_array_end(stream); 456 util_dump_struct_end(stream); 457 util_dump_member_end(stream); 458 459 util_dump_struct_end(stream); 460} 461 462 463void 464util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state) 465{ 466 unsigned i; 467 468 if(!state) { 469 util_dump_null(stream); 470 return; 471 } 472 473 util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state"); 474 475 util_dump_member_begin(stream, "depth"); 476 util_dump_struct_begin(stream, "pipe_depth_state"); 477 util_dump_member(stream, bool, &state->depth, enabled); 478 if (state->depth.enabled) { 479 util_dump_member(stream, bool, &state->depth, writemask); 480 util_dump_member(stream, enum_func, &state->depth, func); 481 } 482 util_dump_struct_end(stream); 483 util_dump_member_end(stream); 484 485 util_dump_member_begin(stream, "stencil"); 486 util_dump_array_begin(stream); 487 for(i = 0; i < Elements(state->stencil); ++i) { 488 util_dump_elem_begin(stream); 489 util_dump_struct_begin(stream, "pipe_stencil_state"); 490 util_dump_member(stream, bool, &state->stencil[i], enabled); 491 if (state->stencil[i].enabled) { 492 util_dump_member(stream, enum_func, &state->stencil[i], func); 493 util_dump_member(stream, uint, &state->stencil[i], fail_op); 494 util_dump_member(stream, uint, &state->stencil[i], zpass_op); 495 util_dump_member(stream, uint, &state->stencil[i], zfail_op); 496 util_dump_member(stream, uint, &state->stencil[i], valuemask); 497 util_dump_member(stream, uint, &state->stencil[i], writemask); 498 } 499 util_dump_struct_end(stream); 500 util_dump_elem_end(stream); 501 } 502 util_dump_array_end(stream); 503 util_dump_member_end(stream); 504 505 util_dump_member_begin(stream, "alpha"); 506 util_dump_struct_begin(stream, "pipe_alpha_state"); 507 util_dump_member(stream, bool, &state->alpha, enabled); 508 if (state->alpha.enabled) { 509 util_dump_member(stream, enum_func, &state->alpha, func); 510 util_dump_member(stream, float, &state->alpha, ref_value); 511 } 512 util_dump_struct_end(stream); 513 util_dump_member_end(stream); 514 515 util_dump_struct_end(stream); 516} 517 518void 519util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state) 520{ 521 util_dump_struct_begin(stream, "pipe_rt_blend_state"); 522 523 util_dump_member(stream, uint, state, blend_enable); 524 if (state->blend_enable) { 525 util_dump_member(stream, enum_blend_func, state, rgb_func); 526 util_dump_member(stream, enum_blend_factor, state, rgb_src_factor); 527 util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor); 528 529 util_dump_member(stream, enum_blend_func, state, alpha_func); 530 util_dump_member(stream, enum_blend_factor, state, alpha_src_factor); 531 util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor); 532 } 533 534 util_dump_member(stream, uint, state, colormask); 535 536 util_dump_struct_end(stream); 537} 538 539void 540util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state) 541{ 542 unsigned valid_entries = 1; 543 544 if(!state) { 545 util_dump_null(stream); 546 return; 547 } 548 549 util_dump_struct_begin(stream, "pipe_blend_state"); 550 551 util_dump_member(stream, bool, state, dither); 552 553 util_dump_member(stream, bool, state, logicop_enable); 554 if (state->logicop_enable) { 555 util_dump_member(stream, enum_func, state, logicop_func); 556 } 557 else { 558 util_dump_member(stream, bool, state, independent_blend_enable); 559 560 util_dump_member_begin(stream, "rt"); 561 if (state->independent_blend_enable) 562 valid_entries = PIPE_MAX_COLOR_BUFS; 563 util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries); 564 util_dump_member_end(stream); 565 } 566 567 util_dump_struct_end(stream); 568} 569 570 571void 572util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state) 573{ 574 if(!state) { 575 util_dump_null(stream); 576 return; 577 } 578 579 util_dump_struct_begin(stream, "pipe_blend_color"); 580 581 util_dump_member_array(stream, float, state, color); 582 583 util_dump_struct_end(stream); 584} 585 586void 587util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state) 588{ 589 if(!state) { 590 util_dump_null(stream); 591 return; 592 } 593 594 util_dump_struct_begin(stream, "pipe_stencil_ref"); 595 596 util_dump_member_array(stream, uint, state, ref_value); 597 598 util_dump_struct_end(stream); 599} 600 601void 602util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state) 603{ 604 util_dump_struct_begin(stream, "pipe_framebuffer_state"); 605 606 util_dump_member(stream, uint, state, width); 607 util_dump_member(stream, uint, state, height); 608 util_dump_member(stream, uint, state, nr_cbufs); 609 util_dump_member_array(stream, ptr, state, cbufs); 610 util_dump_member(stream, ptr, state, zsbuf); 611 612 util_dump_struct_end(stream); 613} 614 615 616void 617util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state) 618{ 619 if(!state) { 620 util_dump_null(stream); 621 return; 622 } 623 624 util_dump_struct_begin(stream, "pipe_sampler_state"); 625 626 util_dump_member(stream, uint, state, wrap_s); 627 util_dump_member(stream, uint, state, wrap_t); 628 util_dump_member(stream, uint, state, wrap_r); 629 util_dump_member(stream, uint, state, min_img_filter); 630 util_dump_member(stream, uint, state, min_mip_filter); 631 util_dump_member(stream, uint, state, mag_img_filter); 632 util_dump_member(stream, uint, state, compare_mode); 633 util_dump_member(stream, enum_func, state, compare_func); 634 util_dump_member(stream, bool, state, normalized_coords); 635 util_dump_member(stream, uint, state, max_anisotropy); 636 util_dump_member(stream, float, state, lod_bias); 637 util_dump_member(stream, float, state, min_lod); 638 util_dump_member(stream, float, state, max_lod); 639 util_dump_member_array(stream, float, state, border_color.f); 640 641 util_dump_struct_end(stream); 642} 643 644 645void 646util_dump_surface(FILE *stream, const struct pipe_surface *state) 647{ 648 if(!state) { 649 util_dump_null(stream); 650 return; 651 } 652 653 util_dump_struct_begin(stream, "pipe_surface"); 654 655 util_dump_member(stream, format, state, format); 656 util_dump_member(stream, uint, state, width); 657 util_dump_member(stream, uint, state, height); 658 659 util_dump_member(stream, uint, state, usage); 660 661 util_dump_member(stream, ptr, state, texture); 662 util_dump_member(stream, uint, state, u.tex.level); 663 util_dump_member(stream, uint, state, u.tex.first_layer); 664 util_dump_member(stream, uint, state, u.tex.last_layer); 665 666 util_dump_struct_end(stream); 667} 668 669 670void 671util_dump_transfer(FILE *stream, const struct pipe_transfer *state) 672{ 673 if(!state) { 674 util_dump_null(stream); 675 return; 676 } 677 678 util_dump_struct_begin(stream, "pipe_transfer"); 679 680 util_dump_member(stream, ptr, state, resource); 681 /*util_dump_member(stream, uint, state, box);*/ 682 683 util_dump_member(stream, uint, state, stride); 684 util_dump_member(stream, uint, state, layer_stride); 685 686 /*util_dump_member(stream, ptr, state, data);*/ 687 688 util_dump_struct_end(stream); 689} 690 691 692void 693util_dump_vertex_buffer(FILE *stream, const struct pipe_vertex_buffer *state) 694{ 695 if(!state) { 696 util_dump_null(stream); 697 return; 698 } 699 700 util_dump_struct_begin(stream, "pipe_vertex_buffer"); 701 702 util_dump_member(stream, uint, state, stride); 703 util_dump_member(stream, uint, state, buffer_offset); 704 util_dump_member(stream, ptr, state, buffer); 705 706 util_dump_struct_end(stream); 707} 708 709 710void 711util_dump_vertex_element(FILE *stream, const struct pipe_vertex_element *state) 712{ 713 if(!state) { 714 util_dump_null(stream); 715 return; 716 } 717 718 util_dump_struct_begin(stream, "pipe_vertex_element"); 719 720 util_dump_member(stream, uint, state, src_offset); 721 722 util_dump_member(stream, uint, state, vertex_buffer_index); 723 724 util_dump_member(stream, format, state, src_format); 725 726 util_dump_struct_end(stream); 727} 728