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