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 <inttypes.h>
36
37#include "u_dump.h"
38
39
40/*
41 * Dump primitives
42 */
43
44static inline void
45util_stream_writef(FILE *stream, const char *format, ...)
46{
47   static char buf[1024];
48   unsigned len;
49   va_list ap;
50   va_start(ap, format);
51   len = util_vsnprintf(buf, sizeof(buf), format, ap);
52   va_end(ap);
53   fwrite(buf, len, 1, stream);
54}
55
56static void
57util_dump_bool(FILE *stream, int value)
58{
59   util_stream_writef(stream, "%c", value ? '1' : '0');
60}
61
62static void
63util_dump_int(FILE *stream, long long int value)
64{
65   util_stream_writef(stream, "%lli", value);
66}
67
68static void
69util_dump_uint(FILE *stream, long long unsigned value)
70{
71   util_stream_writef(stream, "%llu", value);
72}
73
74static void
75util_dump_float(FILE *stream, double value)
76{
77   util_stream_writef(stream, "%g", value);
78}
79
80void
81util_dump_ns(FILE *f, uint64_t time)
82{
83   uint64_t secs = time / (1000*1000*1000);
84   unsigned usecs = (time % (1000*1000*1000)) / 1000;
85   fprintf(f, "%"PRIu64".%06us", secs, usecs);
86}
87
88static void
89util_dump_string(FILE *stream, const char *str)
90{
91   fputs("\"", stream);
92   fputs(str, stream);
93   fputs("\"", stream);
94}
95
96static void
97util_dump_enum(FILE *stream, const char *value)
98{
99   fputs(value, stream);
100}
101
102static void
103util_dump_array_begin(FILE *stream)
104{
105   fputs("{", stream);
106}
107
108static void
109util_dump_array_end(FILE *stream)
110{
111   fputs("}", stream);
112}
113
114static void
115util_dump_elem_begin(UNUSED FILE *stream)
116{
117}
118
119static void
120util_dump_elem_end(FILE *stream)
121{
122   fputs(", ", stream);
123}
124
125static void
126util_dump_struct_begin(FILE *stream, UNUSED const char *name)
127{
128   fputs("{", stream);
129}
130
131static void
132util_dump_struct_end(FILE *stream)
133{
134   fputs("}", stream);
135}
136
137static void
138util_dump_member_begin(FILE *stream, const char *name)
139{
140   util_stream_writef(stream, "%s = ", name);
141}
142
143static void
144util_dump_member_end(FILE *stream)
145{
146   fputs(", ", stream);
147}
148
149static void
150util_dump_null(FILE *stream)
151{
152   fputs("NULL", stream);
153}
154
155void
156util_dump_ptr(FILE *stream, const void *value)
157{
158   if(value)
159      util_stream_writef(stream, "%p", value);
160   else
161      util_dump_null(stream);
162}
163
164
165/*
166 * Code saving macros.
167 */
168
169#define util_dump_arg(_stream, _type, _arg) \
170   do { \
171      util_dump_arg_begin(_stream, #_arg); \
172      util_dump_##_type(_stream, _arg); \
173      util_dump_arg_end(_stream); \
174   } while(0)
175
176#define util_dump_ret(_stream, _type, _arg) \
177   do { \
178      util_dump_ret_begin(_stream); \
179      util_dump_##_type(_stream, _arg); \
180      util_dump_ret_end(_stream); \
181   } while(0)
182
183#define util_dump_array(_stream, _type, _obj, _size) \
184   do { \
185      size_t idx; \
186      util_dump_array_begin(_stream); \
187      for(idx = 0; idx < (_size); ++idx) { \
188         util_dump_elem_begin(_stream); \
189         util_dump_##_type(_stream, (_obj)[idx]); \
190         util_dump_elem_end(_stream); \
191      } \
192      util_dump_array_end(_stream); \
193   } while(0)
194
195#define util_dump_struct_array(_stream, _type, _obj, _size) \
196   do { \
197      size_t idx; \
198      util_dump_array_begin(_stream); \
199      for(idx = 0; idx < (_size); ++idx) { \
200         util_dump_elem_begin(_stream); \
201         util_dump_##_type(_stream, &(_obj)[idx]); \
202         util_dump_elem_end(_stream); \
203      } \
204      util_dump_array_end(_stream); \
205   } while(0)
206
207#define util_dump_member(_stream, _type, _obj, _member) \
208   do { \
209      util_dump_member_begin(_stream, #_member); \
210      util_dump_##_type(_stream, (_obj)->_member); \
211      util_dump_member_end(_stream); \
212   } while(0)
213
214#define util_dump_arg_array(_stream, _type, _arg, _size) \
215   do { \
216      util_dump_arg_begin(_stream, #_arg); \
217      util_dump_array(_stream, _type, _arg, _size); \
218      util_dump_arg_end(_stream); \
219   } while(0)
220
221#define util_dump_member_array(_stream, _type, _obj, _member) \
222   do { \
223      util_dump_member_begin(_stream, #_member); \
224      util_dump_array(_stream, _type, (_obj)->_member, sizeof((_obj)->_member)/sizeof((_obj)->_member[0])); \
225      util_dump_member_end(_stream); \
226   } while(0)
227
228
229
230/*
231 * Wrappers for enum -> string dumpers.
232 */
233
234
235static void
236util_dump_format(FILE *stream, enum pipe_format format)
237{
238   util_dump_enum(stream, util_format_name(format));
239}
240
241
242static void
243util_dump_enum_blend_factor(FILE *stream, unsigned value)
244{
245   util_dump_enum(stream, util_str_blend_factor(value, TRUE));
246}
247
248static void
249util_dump_enum_blend_func(FILE *stream, unsigned value)
250{
251   util_dump_enum(stream, util_str_blend_func(value, TRUE));
252}
253
254static void
255util_dump_enum_func(FILE *stream, unsigned value)
256{
257   util_dump_enum(stream, util_str_func(value, TRUE));
258}
259
260static void
261util_dump_enum_prim_mode(FILE *stream, unsigned value)
262{
263   util_dump_enum(stream, util_str_prim_mode(value, TRUE));
264}
265
266static void
267util_dump_enum_tex_target(FILE *stream, unsigned value)
268{
269   util_dump_enum(stream, util_str_tex_target(value, TRUE));
270}
271
272static void
273util_dump_enum_tex_filter(FILE *stream, unsigned value)
274{
275   util_dump_enum(stream, util_str_tex_filter(value, TRUE));
276}
277
278static void
279util_dump_enum_tex_mipfilter(FILE *stream, unsigned value)
280{
281   util_dump_enum(stream, util_str_tex_mipfilter(value, TRUE));
282}
283
284static void
285util_dump_enum_tex_wrap(FILE *stream, unsigned value)
286{
287   util_dump_enum(stream, util_str_tex_wrap(value, TRUE));
288}
289
290static void
291util_dump_enum_stencil_op(FILE *stream, unsigned value)
292{
293   util_dump_enum(stream, util_str_stencil_op(value, TRUE));
294}
295
296
297/*
298 * Public functions
299 */
300
301
302void
303util_dump_resource(FILE *stream, const struct pipe_resource *state)
304{
305   if (!state) {
306      util_dump_null(stream);
307      return;
308   }
309
310   util_dump_struct_begin(stream, "pipe_resource");
311
312   util_dump_member(stream, enum_tex_target, state, target);
313   util_dump_member(stream, format, state, format);
314
315   util_dump_member(stream, uint, state, width0);
316   util_dump_member(stream, uint, state, height0);
317   util_dump_member(stream, uint, state, depth0);
318   util_dump_member(stream, uint, state, array_size);
319
320   util_dump_member(stream, uint, state, last_level);
321   util_dump_member(stream, uint, state, nr_samples);
322   util_dump_member(stream, uint, state, nr_storage_samples);
323   util_dump_member(stream, uint, state, usage);
324   util_dump_member(stream, uint, state, bind);
325   util_dump_member(stream, uint, state, flags);
326
327   util_dump_struct_end(stream);
328}
329
330
331void
332util_dump_rasterizer_state(FILE *stream, const struct pipe_rasterizer_state *state)
333{
334   if (!state) {
335      util_dump_null(stream);
336      return;
337   }
338
339   util_dump_struct_begin(stream, "pipe_rasterizer_state");
340
341   util_dump_member(stream, bool, state, flatshade);
342   util_dump_member(stream, bool, state, light_twoside);
343   util_dump_member(stream, bool, state, clamp_vertex_color);
344   util_dump_member(stream, bool, state, clamp_fragment_color);
345   util_dump_member(stream, uint, state, front_ccw);
346   util_dump_member(stream, uint, state, cull_face);
347   util_dump_member(stream, uint, state, fill_front);
348   util_dump_member(stream, uint, state, fill_back);
349   util_dump_member(stream, bool, state, offset_point);
350   util_dump_member(stream, bool, state, offset_line);
351   util_dump_member(stream, bool, state, offset_tri);
352   util_dump_member(stream, bool, state, scissor);
353   util_dump_member(stream, bool, state, poly_smooth);
354   util_dump_member(stream, bool, state, poly_stipple_enable);
355   util_dump_member(stream, bool, state, point_smooth);
356   util_dump_member(stream, uint, state, sprite_coord_enable);
357   util_dump_member(stream, bool, state, sprite_coord_mode);
358   util_dump_member(stream, bool, state, point_quad_rasterization);
359   util_dump_member(stream, bool, state, point_tri_clip);
360   util_dump_member(stream, bool, state, point_size_per_vertex);
361   util_dump_member(stream, bool, state, multisample);
362   util_dump_member(stream, bool, state, line_smooth);
363   util_dump_member(stream, bool, state, line_stipple_enable);
364   util_dump_member(stream, uint, state, line_stipple_factor);
365   util_dump_member(stream, uint, state, line_stipple_pattern);
366   util_dump_member(stream, bool, state, line_last_pixel);
367   util_dump_member(stream, bool, state, flatshade_first);
368   util_dump_member(stream, bool, state, half_pixel_center);
369   util_dump_member(stream, bool, state, bottom_edge_rule);
370   util_dump_member(stream, bool, state, rasterizer_discard);
371   util_dump_member(stream, bool, state, depth_clip_near);
372   util_dump_member(stream, bool, state, depth_clip_far);
373   util_dump_member(stream, bool, state, clip_halfz);
374   util_dump_member(stream, uint, state, clip_plane_enable);
375
376   util_dump_member(stream, float, state, line_width);
377   util_dump_member(stream, float, state, point_size);
378   util_dump_member(stream, float, state, offset_units);
379   util_dump_member(stream, float, state, offset_scale);
380   util_dump_member(stream, float, state, offset_clamp);
381
382   util_dump_struct_end(stream);
383}
384
385
386void
387util_dump_poly_stipple(FILE *stream, const struct pipe_poly_stipple *state)
388{
389   if (!state) {
390      util_dump_null(stream);
391      return;
392   }
393
394   util_dump_struct_begin(stream, "pipe_poly_stipple");
395
396   util_dump_member_begin(stream, "stipple");
397   util_dump_member_array(stream, uint, state, stipple);
398   util_dump_member_end(stream);
399
400   util_dump_struct_end(stream);
401}
402
403
404void
405util_dump_viewport_state(FILE *stream, const struct pipe_viewport_state *state)
406{
407   if (!state) {
408      util_dump_null(stream);
409      return;
410   }
411
412   util_dump_struct_begin(stream, "pipe_viewport_state");
413
414   util_dump_member_array(stream, float, state, scale);
415   util_dump_member_array(stream, float, state, translate);
416
417   util_dump_struct_end(stream);
418}
419
420
421void
422util_dump_scissor_state(FILE *stream, const struct pipe_scissor_state *state)
423{
424   if (!state) {
425      util_dump_null(stream);
426      return;
427   }
428
429   util_dump_struct_begin(stream, "pipe_scissor_state");
430
431   util_dump_member(stream, uint, state, minx);
432   util_dump_member(stream, uint, state, miny);
433   util_dump_member(stream, uint, state, maxx);
434   util_dump_member(stream, uint, state, maxy);
435
436   util_dump_struct_end(stream);
437}
438
439
440void
441util_dump_clip_state(FILE *stream, const struct pipe_clip_state *state)
442{
443   unsigned i;
444
445   if (!state) {
446      util_dump_null(stream);
447      return;
448   }
449
450   util_dump_struct_begin(stream, "pipe_clip_state");
451
452   util_dump_member_begin(stream, "ucp");
453   util_dump_array_begin(stream);
454   for(i = 0; i < PIPE_MAX_CLIP_PLANES; ++i) {
455      util_dump_elem_begin(stream);
456      util_dump_array(stream, float, state->ucp[i], 4);
457      util_dump_elem_end(stream);
458   }
459   util_dump_array_end(stream);
460   util_dump_member_end(stream);
461
462   util_dump_struct_end(stream);
463}
464
465
466void
467util_dump_shader_state(FILE *stream, const struct pipe_shader_state *state)
468{
469   unsigned i;
470
471   if (!state) {
472      util_dump_null(stream);
473      return;
474   }
475
476   util_dump_struct_begin(stream, "pipe_shader_state");
477
478   if (state->type == PIPE_SHADER_IR_TGSI) {
479      util_dump_member_begin(stream, "tokens");
480      fprintf(stream, "\"\n");
481      tgsi_dump_to_file(state->tokens, 0, stream);
482      fprintf(stream, "\"");
483      util_dump_member_end(stream);
484   }
485
486   if (state->stream_output.num_outputs) {
487      util_dump_member_begin(stream, "stream_output");
488      util_dump_struct_begin(stream, "pipe_stream_output_info");
489      util_dump_member(stream, uint, &state->stream_output, num_outputs);
490      util_dump_array(stream, uint, state->stream_output.stride,
491                      ARRAY_SIZE(state->stream_output.stride));
492      util_dump_array_begin(stream);
493      for(i = 0; i < state->stream_output.num_outputs; ++i) {
494         util_dump_elem_begin(stream);
495         util_dump_struct_begin(stream, ""); /* anonymous */
496         util_dump_member(stream, uint, &state->stream_output.output[i], register_index);
497         util_dump_member(stream, uint, &state->stream_output.output[i], start_component);
498         util_dump_member(stream, uint, &state->stream_output.output[i], num_components);
499         util_dump_member(stream, uint, &state->stream_output.output[i], output_buffer);
500         util_dump_struct_end(stream);
501         util_dump_elem_end(stream);
502      }
503      util_dump_array_end(stream);
504      util_dump_struct_end(stream);
505      util_dump_member_end(stream);
506   }
507
508   util_dump_struct_end(stream);
509}
510
511
512void
513util_dump_depth_stencil_alpha_state(FILE *stream, const struct pipe_depth_stencil_alpha_state *state)
514{
515   unsigned i;
516
517   if (!state) {
518      util_dump_null(stream);
519      return;
520   }
521
522   util_dump_struct_begin(stream, "pipe_depth_stencil_alpha_state");
523
524   util_dump_member_begin(stream, "depth");
525   util_dump_struct_begin(stream, "pipe_depth_state");
526   util_dump_member(stream, bool, &state->depth, enabled);
527   if (state->depth.enabled) {
528      util_dump_member(stream, bool, &state->depth, writemask);
529      util_dump_member(stream, enum_func, &state->depth, func);
530   }
531   util_dump_struct_end(stream);
532   util_dump_member_end(stream);
533
534   util_dump_member_begin(stream, "stencil");
535   util_dump_array_begin(stream);
536   for(i = 0; i < ARRAY_SIZE(state->stencil); ++i) {
537      util_dump_elem_begin(stream);
538      util_dump_struct_begin(stream, "pipe_stencil_state");
539      util_dump_member(stream, bool, &state->stencil[i], enabled);
540      if (state->stencil[i].enabled) {
541         util_dump_member(stream, enum_func, &state->stencil[i], func);
542         util_dump_member(stream, enum_stencil_op,
543                          &state->stencil[i], fail_op);
544         util_dump_member(stream, enum_stencil_op,
545                          &state->stencil[i], zpass_op);
546         util_dump_member(stream, enum_stencil_op,
547                          &state->stencil[i], zfail_op);
548         util_dump_member(stream, uint, &state->stencil[i], valuemask);
549         util_dump_member(stream, uint, &state->stencil[i], writemask);
550      }
551      util_dump_struct_end(stream);
552      util_dump_elem_end(stream);
553   }
554   util_dump_array_end(stream);
555   util_dump_member_end(stream);
556
557   util_dump_member_begin(stream, "alpha");
558   util_dump_struct_begin(stream, "pipe_alpha_state");
559   util_dump_member(stream, bool, &state->alpha, enabled);
560   if (state->alpha.enabled) {
561      util_dump_member(stream, enum_func, &state->alpha, func);
562      util_dump_member(stream, float, &state->alpha, ref_value);
563   }
564   util_dump_struct_end(stream);
565   util_dump_member_end(stream);
566
567   util_dump_struct_end(stream);
568}
569
570void
571util_dump_rt_blend_state(FILE *stream, const struct pipe_rt_blend_state *state)
572{
573   util_dump_struct_begin(stream, "pipe_rt_blend_state");
574
575   util_dump_member(stream, uint, state, blend_enable);
576   if (state->blend_enable) {
577      util_dump_member(stream, enum_blend_func, state, rgb_func);
578      util_dump_member(stream, enum_blend_factor, state, rgb_src_factor);
579      util_dump_member(stream, enum_blend_factor, state, rgb_dst_factor);
580
581      util_dump_member(stream, enum_blend_func, state, alpha_func);
582      util_dump_member(stream, enum_blend_factor, state, alpha_src_factor);
583      util_dump_member(stream, enum_blend_factor, state, alpha_dst_factor);
584   }
585
586   util_dump_member(stream, uint, state, colormask);
587
588   util_dump_struct_end(stream);
589}
590
591void
592util_dump_blend_state(FILE *stream, const struct pipe_blend_state *state)
593{
594   unsigned valid_entries = 1;
595
596   if (!state) {
597      util_dump_null(stream);
598      return;
599   }
600
601   util_dump_struct_begin(stream, "pipe_blend_state");
602
603   util_dump_member(stream, bool, state, dither);
604   util_dump_member(stream, bool, state, alpha_to_coverage);
605   util_dump_member(stream, bool, state, alpha_to_one);
606
607   util_dump_member(stream, bool, state, logicop_enable);
608   if (state->logicop_enable) {
609      util_dump_member(stream, enum_func, state, logicop_func);
610   }
611   else {
612      util_dump_member(stream, bool, state, independent_blend_enable);
613
614      util_dump_member_begin(stream, "rt");
615      if (state->independent_blend_enable)
616         valid_entries = PIPE_MAX_COLOR_BUFS;
617      util_dump_struct_array(stream, rt_blend_state, state->rt, valid_entries);
618      util_dump_member_end(stream);
619   }
620
621   util_dump_struct_end(stream);
622}
623
624
625void
626util_dump_blend_color(FILE *stream, const struct pipe_blend_color *state)
627{
628   if (!state) {
629      util_dump_null(stream);
630      return;
631   }
632
633   util_dump_struct_begin(stream, "pipe_blend_color");
634
635   util_dump_member_array(stream, float, state, color);
636
637   util_dump_struct_end(stream);
638}
639
640void
641util_dump_stencil_ref(FILE *stream, const struct pipe_stencil_ref *state)
642{
643   if (!state) {
644      util_dump_null(stream);
645      return;
646   }
647
648   util_dump_struct_begin(stream, "pipe_stencil_ref");
649
650   util_dump_member_array(stream, uint, state, ref_value);
651
652   util_dump_struct_end(stream);
653}
654
655void
656util_dump_framebuffer_state(FILE *stream, const struct pipe_framebuffer_state *state)
657{
658   util_dump_struct_begin(stream, "pipe_framebuffer_state");
659
660   util_dump_member(stream, uint, state, width);
661   util_dump_member(stream, uint, state, height);
662   util_dump_member(stream, uint, state, samples);
663   util_dump_member(stream, uint, state, layers);
664   util_dump_member(stream, uint, state, nr_cbufs);
665   util_dump_member_array(stream, ptr, state, cbufs);
666   util_dump_member(stream, ptr, state, zsbuf);
667
668   util_dump_struct_end(stream);
669}
670
671
672void
673util_dump_sampler_state(FILE *stream, const struct pipe_sampler_state *state)
674{
675   if (!state) {
676      util_dump_null(stream);
677      return;
678   }
679
680   util_dump_struct_begin(stream, "pipe_sampler_state");
681
682   util_dump_member(stream, enum_tex_wrap, state, wrap_s);
683   util_dump_member(stream, enum_tex_wrap, state, wrap_t);
684   util_dump_member(stream, enum_tex_wrap, state, wrap_r);
685   util_dump_member(stream, enum_tex_filter, state, min_img_filter);
686   util_dump_member(stream, enum_tex_mipfilter, state, min_mip_filter);
687   util_dump_member(stream, enum_tex_filter, state, mag_img_filter);
688   util_dump_member(stream, uint, state, compare_mode);
689   util_dump_member(stream, enum_func, state, compare_func);
690   util_dump_member(stream, bool, state, normalized_coords);
691   util_dump_member(stream, uint, state, max_anisotropy);
692   util_dump_member(stream, bool, state, seamless_cube_map);
693   util_dump_member(stream, float, state, lod_bias);
694   util_dump_member(stream, float, state, min_lod);
695   util_dump_member(stream, float, state, max_lod);
696   util_dump_member_array(stream, float, state, border_color.f);
697
698   util_dump_struct_end(stream);
699}
700
701
702void
703util_dump_surface(FILE *stream, const struct pipe_surface *state)
704{
705   if (!state) {
706      util_dump_null(stream);
707      return;
708   }
709
710   util_dump_struct_begin(stream, "pipe_surface");
711
712   util_dump_member(stream, format, state, format);
713   util_dump_member(stream, uint, state, width);
714   util_dump_member(stream, uint, state, height);
715
716   util_dump_member(stream, ptr, state, texture);
717   util_dump_member(stream, uint, state, u.tex.level);
718   util_dump_member(stream, uint, state, u.tex.first_layer);
719   util_dump_member(stream, uint, state, u.tex.last_layer);
720
721   util_dump_struct_end(stream);
722}
723
724
725void
726util_dump_image_view(FILE *stream, const struct pipe_image_view *state)
727{
728   if (!state) {
729      util_dump_null(stream);
730      return;
731   }
732
733   util_dump_struct_begin(stream, "pipe_image_view");
734
735   util_dump_member(stream, ptr, state, resource);
736   util_dump_member(stream, format, state, format);
737
738   if (state->resource->target == PIPE_BUFFER) {
739      util_dump_member(stream, uint, state, u.buf.offset);
740      util_dump_member(stream, uint, state, u.buf.size);
741   }
742   else {
743      util_dump_member(stream, uint, state, u.tex.first_layer);
744      util_dump_member(stream, uint, state, u.tex.last_layer);
745      util_dump_member(stream, uint, state, u.tex.level);
746   }
747
748   util_dump_struct_end(stream);
749}
750
751
752void
753util_dump_shader_buffer(FILE *stream, const struct pipe_shader_buffer *state)
754{
755   if (!state) {
756      util_dump_null(stream);
757      return;
758   }
759
760   util_dump_struct_begin(stream, "pipe_shader_buffer");
761
762   util_dump_member(stream, ptr, state, buffer);
763   util_dump_member(stream, uint, state, buffer_offset);
764   util_dump_member(stream, uint, state, buffer_size);
765
766   util_dump_struct_end(stream);
767
768}
769
770
771void
772util_dump_sampler_view(FILE *stream, const struct pipe_sampler_view *state)
773{
774   if (!state) {
775      util_dump_null(stream);
776      return;
777   }
778
779   util_dump_struct_begin(stream, "pipe_sampler_view");
780
781   util_dump_member(stream, enum_tex_target, state, target);
782   util_dump_member(stream, format, state, format);
783   util_dump_member(stream, ptr, state, texture);
784
785   if (state->target == PIPE_BUFFER) {
786      util_dump_member(stream, uint, state, u.buf.offset);
787      util_dump_member(stream, uint, state, u.buf.size);
788   }
789   else {
790      util_dump_member(stream, uint, state, u.tex.first_layer);
791      util_dump_member(stream, uint, state, u.tex.last_layer);
792      util_dump_member(stream, uint, state, u.tex.first_level);
793      util_dump_member(stream, uint, state, u.tex.last_level);
794   }
795
796   util_dump_member(stream, uint, state, swizzle_r);
797   util_dump_member(stream, uint, state, swizzle_g);
798   util_dump_member(stream, uint, state, swizzle_b);
799   util_dump_member(stream, uint, state, swizzle_a);
800
801   util_dump_struct_end(stream);
802}
803
804
805void
806util_dump_transfer(FILE *stream, const struct pipe_transfer *state)
807{
808   if (!state) {
809      util_dump_null(stream);
810      return;
811   }
812
813   util_dump_struct_begin(stream, "pipe_transfer");
814
815   util_dump_member(stream, ptr, state, resource);
816   util_dump_member(stream, uint, state, level);
817   util_dump_member(stream, transfer_usage, state, usage);
818   util_dump_member_begin(stream, "box");
819   util_dump_box(stream, &state->box);
820   util_dump_member_end(stream);
821   util_dump_member(stream, uint, state, stride);
822   util_dump_member(stream, uint, state, layer_stride);
823
824   util_dump_struct_end(stream);
825}
826
827
828void
829util_dump_constant_buffer(FILE *stream,
830                          const struct pipe_constant_buffer *state)
831{
832   if (!state) {
833      util_dump_null(stream);
834      return;
835   }
836
837   util_dump_struct_begin(stream, "pipe_constant_buffer");
838
839   util_dump_member(stream, ptr, state, buffer);
840   util_dump_member(stream, uint, state, buffer_offset);
841   util_dump_member(stream, uint, state, buffer_size);
842   util_dump_member(stream, ptr, state, user_buffer);
843
844   util_dump_struct_end(stream);
845}
846
847
848void
849util_dump_vertex_buffer(FILE *stream, const struct pipe_vertex_buffer *state)
850{
851   if (!state) {
852      util_dump_null(stream);
853      return;
854   }
855
856   util_dump_struct_begin(stream, "pipe_vertex_buffer");
857
858   util_dump_member(stream, uint, state, stride);
859   util_dump_member(stream, bool, state, is_user_buffer);
860   util_dump_member(stream, uint, state, buffer_offset);
861   util_dump_member(stream, ptr, state, buffer.resource);
862
863   util_dump_struct_end(stream);
864}
865
866
867void
868util_dump_vertex_element(FILE *stream, const struct pipe_vertex_element *state)
869{
870   if (!state) {
871      util_dump_null(stream);
872      return;
873   }
874
875   util_dump_struct_begin(stream, "pipe_vertex_element");
876
877   util_dump_member(stream, uint, state, src_offset);
878   util_dump_member(stream, uint, state, instance_divisor);
879   util_dump_member(stream, uint, state, vertex_buffer_index);
880   util_dump_member(stream, format, state, src_format);
881
882   util_dump_struct_end(stream);
883}
884
885
886void
887util_dump_stream_output_target(FILE *stream,
888                               const struct pipe_stream_output_target *state)
889{
890   if (!state) {
891      util_dump_null(stream);
892      return;
893   }
894
895   util_dump_struct_begin(stream, "pipe_stream_output_target");
896
897   util_dump_member(stream, ptr, state, buffer);
898   util_dump_member(stream, uint, state, buffer_offset);
899   util_dump_member(stream, uint, state, buffer_size);
900
901   util_dump_struct_end(stream);
902}
903
904
905void
906util_dump_draw_info(FILE *stream, const struct pipe_draw_info *state)
907{
908   if (!state) {
909      util_dump_null(stream);
910      return;
911   }
912
913   util_dump_struct_begin(stream, "pipe_draw_info");
914
915   util_dump_member(stream, uint, state, index_size);
916   util_dump_member(stream, uint, state, has_user_indices);
917
918   util_dump_member(stream, enum_prim_mode, state, mode);
919   util_dump_member(stream, uint, state, start);
920   util_dump_member(stream, uint, state, count);
921
922   util_dump_member(stream, uint, state, start_instance);
923   util_dump_member(stream, uint, state, instance_count);
924
925   util_dump_member(stream, uint, state, drawid);
926
927   util_dump_member(stream, uint, state, vertices_per_patch);
928
929   util_dump_member(stream, int,  state, index_bias);
930   util_dump_member(stream, uint, state, min_index);
931   util_dump_member(stream, uint, state, max_index);
932
933   util_dump_member(stream, bool, state, primitive_restart);
934   if (state->primitive_restart)
935      util_dump_member(stream, uint, state, restart_index);
936
937   if (state->index_size) {
938      if (state->has_user_indices)
939         util_dump_member(stream, ptr, state, index.user);
940      else
941         util_dump_member(stream, ptr, state, index.resource);
942   }
943   util_dump_member(stream, ptr, state, count_from_stream_output);
944
945   if (!state->indirect) {
946      util_dump_member(stream, ptr, state, indirect);
947   } else {
948      util_dump_member(stream, uint, state, indirect->offset);
949      util_dump_member(stream, uint, state, indirect->stride);
950      util_dump_member(stream, uint, state, indirect->draw_count);
951      util_dump_member(stream, uint, state, indirect->indirect_draw_count_offset);
952      util_dump_member(stream, ptr, state, indirect->buffer);
953      util_dump_member(stream, ptr, state, indirect->indirect_draw_count);
954   }
955
956   util_dump_struct_end(stream);
957}
958
959void util_dump_grid_info(FILE *stream, const struct pipe_grid_info *state)
960{
961   if (!state) {
962      util_dump_null(stream);
963      return;
964   }
965
966   util_dump_struct_begin(stream, "pipe_grid_info");
967
968   util_dump_member(stream, uint, state, pc);
969   util_dump_member(stream, ptr, state, input);
970   util_dump_member(stream, uint, state, work_dim);
971
972   util_dump_member_begin(stream, "block");
973   util_dump_array(stream, uint, state->block, ARRAY_SIZE(state->block));
974   util_dump_member_end(stream);
975
976   util_dump_member_begin(stream, "grid");
977   util_dump_array(stream, uint, state->grid, ARRAY_SIZE(state->grid));
978   util_dump_member_end(stream);
979
980   util_dump_member(stream, ptr, state, indirect);
981   util_dump_member(stream, uint, state, indirect_offset);
982
983   util_dump_struct_end(stream);
984}
985
986void util_dump_box(FILE *stream, const struct pipe_box *box)
987{
988   if (!box) {
989      util_dump_null(stream);
990      return;
991   }
992
993   util_dump_struct_begin(stream, "pipe_box");
994
995   util_dump_member(stream, int, box, x);
996   util_dump_member(stream, int, box, y);
997   util_dump_member(stream, int, box, z);
998   util_dump_member(stream, int, box, width);
999   util_dump_member(stream, int, box, height);
1000   util_dump_member(stream, int, box, depth);
1001
1002   util_dump_struct_end(stream);
1003}
1004
1005void util_dump_blit_info(FILE *stream, const struct pipe_blit_info *info)
1006{
1007   char mask[7];
1008
1009   if (!info) {
1010      util_dump_null(stream);
1011      return;
1012   }
1013
1014   util_dump_struct_begin(stream, "pipe_blit_info");
1015
1016   util_dump_member_begin(stream, "dst");
1017   util_dump_struct_begin(stream, "dst");
1018   util_dump_member(stream, ptr, &info->dst, resource);
1019   util_dump_member(stream, uint, &info->dst, level);
1020   util_dump_member(stream, format, &info->dst, format);
1021   util_dump_member_begin(stream, "box");
1022   util_dump_box(stream, &info->dst.box);
1023   util_dump_member_end(stream);
1024   util_dump_struct_end(stream);
1025   util_dump_member_end(stream);
1026
1027   util_dump_member_begin(stream, "src");
1028   util_dump_struct_begin(stream, "src");
1029   util_dump_member(stream, ptr, &info->src, resource);
1030   util_dump_member(stream, uint, &info->src, level);
1031   util_dump_member(stream, format, &info->src, format);
1032   util_dump_member_begin(stream, "box");
1033   util_dump_box(stream, &info->src.box);
1034   util_dump_member_end(stream);
1035   util_dump_struct_end(stream);
1036   util_dump_member_end(stream);
1037
1038   mask[0] = (info->mask & PIPE_MASK_R) ? 'R' : '-';
1039   mask[1] = (info->mask & PIPE_MASK_G) ? 'G' : '-';
1040   mask[2] = (info->mask & PIPE_MASK_B) ? 'B' : '-';
1041   mask[3] = (info->mask & PIPE_MASK_A) ? 'A' : '-';
1042   mask[4] = (info->mask & PIPE_MASK_Z) ? 'Z' : '-';
1043   mask[5] = (info->mask & PIPE_MASK_S) ? 'S' : '-';
1044   mask[6] = 0;
1045
1046   util_dump_member_begin(stream, "mask");
1047   util_dump_string(stream, mask);
1048   util_dump_member_end(stream);
1049   util_dump_member(stream, enum_tex_filter, info, filter);
1050
1051   util_dump_member(stream, bool, info, scissor_enable);
1052   util_dump_member_begin(stream, "scissor");
1053   util_dump_scissor_state(stream, &info->scissor);
1054   util_dump_member_end(stream);
1055
1056   util_dump_member(stream, bool, info, render_condition_enable);
1057
1058   util_dump_struct_end(stream);
1059}
1060