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
38void 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
47void 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
87void 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
110void 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
163void 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
185void 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
204void 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
225void 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
253void 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
300void 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
351static 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
370void 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
401void 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
418void 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
435void 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
452void 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
483void 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
529void 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
573void 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
602void 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
622void 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
642void 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
664void 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