gallium/hud: fix a problem where objects are free'd while in use.
[mesa.git] / src / gallium / auxiliary / hud / hud_context.c
1 /**************************************************************************
2 *
3 * Copyright 2013 Marek Olšák <maraeo@gmail.com>
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 THE AUTHORS 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 /* This head-up display module can draw transparent graphs on top of what
29 * the app is rendering, visualizing various data like framerate, cpu load,
30 * performance counters, etc. It can be hook up into any state tracker.
31 *
32 * The HUD is controlled with the GALLIUM_HUD environment variable.
33 * Set GALLIUM_HUD=help for more info.
34 */
35
36 #include <signal.h>
37 #include <stdio.h>
38
39 #include "hud/hud_context.h"
40 #include "hud/hud_private.h"
41 #include "hud/font.h"
42
43 #include "cso_cache/cso_context.h"
44 #include "util/u_draw_quad.h"
45 #include "util/u_format.h"
46 #include "util/u_inlines.h"
47 #include "util/u_memory.h"
48 #include "util/u_math.h"
49 #include "util/u_sampler.h"
50 #include "util/u_simple_shaders.h"
51 #include "util/u_string.h"
52 #include "util/u_upload_mgr.h"
53 #include "tgsi/tgsi_text.h"
54 #include "tgsi/tgsi_dump.h"
55
56 /* Control the visibility of all HUD contexts */
57 static boolean huds_visible = TRUE;
58
59 struct hud_context {
60 struct pipe_context *pipe;
61 struct cso_context *cso;
62 struct u_upload_mgr *uploader;
63
64 struct hud_batch_query_context *batch_query;
65 struct list_head pane_list;
66
67 /* states */
68 struct pipe_blend_state no_blend, alpha_blend;
69 struct pipe_depth_stencil_alpha_state dsa;
70 void *fs_color, *fs_text;
71 struct pipe_rasterizer_state rasterizer, rasterizer_aa_lines;
72 void *vs;
73 struct pipe_vertex_element velems[2];
74
75 /* font */
76 struct util_font font;
77 struct pipe_sampler_view *font_sampler_view;
78 struct pipe_sampler_state font_sampler_state;
79
80 /* VS constant buffer */
81 struct {
82 float color[4];
83 float two_div_fb_width;
84 float two_div_fb_height;
85 float translate[2];
86 float scale[2];
87 float padding[2];
88 } constants;
89 struct pipe_constant_buffer constbuf;
90
91 unsigned fb_width, fb_height;
92
93 /* vertices for text and background drawing are accumulated here and then
94 * drawn all at once */
95 struct vertex_queue {
96 float *vertices;
97 struct pipe_vertex_buffer vbuf;
98 unsigned max_num_vertices;
99 unsigned num_vertices;
100 } text, bg, whitelines;
101
102 bool has_srgb;
103 };
104
105 #ifdef PIPE_OS_UNIX
106 static void
107 signal_visible_handler(int sig, siginfo_t *siginfo, void *context)
108 {
109 huds_visible = !huds_visible;
110 }
111 #endif
112
113 static void
114 hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
115 float *buffer, unsigned num_vertices,
116 float r, float g, float b, float a,
117 int xoffset, int yoffset, float yscale)
118 {
119 struct cso_context *cso = hud->cso;
120 struct pipe_vertex_buffer vbuffer = {0};
121
122 hud->constants.color[0] = r;
123 hud->constants.color[1] = g;
124 hud->constants.color[2] = b;
125 hud->constants.color[3] = a;
126 hud->constants.translate[0] = (float) xoffset;
127 hud->constants.translate[1] = (float) yoffset;
128 hud->constants.scale[0] = 1;
129 hud->constants.scale[1] = yscale;
130 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
131
132 vbuffer.user_buffer = buffer;
133 vbuffer.stride = 2 * sizeof(float);
134
135 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso),
136 1, &vbuffer);
137 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
138 cso_draw_arrays(cso, prim, 0, num_vertices);
139 }
140
141 static void
142 hud_draw_colored_quad(struct hud_context *hud, unsigned prim,
143 unsigned x1, unsigned y1, unsigned x2, unsigned y2,
144 float r, float g, float b, float a)
145 {
146 float buffer[] = {
147 (float) x1, (float) y1,
148 (float) x1, (float) y2,
149 (float) x2, (float) y2,
150 (float) x2, (float) y1,
151 };
152
153 hud_draw_colored_prims(hud, prim, buffer, 4, r, g, b, a, 0, 0, 1);
154 }
155
156 static void
157 hud_draw_background_quad(struct hud_context *hud,
158 unsigned x1, unsigned y1, unsigned x2, unsigned y2)
159 {
160 float *vertices = hud->bg.vertices + hud->bg.num_vertices*2;
161 unsigned num = 0;
162
163 assert(hud->bg.num_vertices + 4 <= hud->bg.max_num_vertices);
164
165 vertices[num++] = (float) x1;
166 vertices[num++] = (float) y1;
167
168 vertices[num++] = (float) x1;
169 vertices[num++] = (float) y2;
170
171 vertices[num++] = (float) x2;
172 vertices[num++] = (float) y2;
173
174 vertices[num++] = (float) x2;
175 vertices[num++] = (float) y1;
176
177 hud->bg.num_vertices += num/2;
178 }
179
180 static void
181 hud_draw_string(struct hud_context *hud, unsigned x, unsigned y,
182 const char *str, ...)
183 {
184 char buf[256];
185 char *s = buf;
186 float *vertices = hud->text.vertices + hud->text.num_vertices*4;
187 unsigned num = 0;
188
189 va_list ap;
190 va_start(ap, str);
191 util_vsnprintf(buf, sizeof(buf), str, ap);
192 va_end(ap);
193
194 if (!*s)
195 return;
196
197 hud_draw_background_quad(hud,
198 x, y,
199 x + strlen(buf)*hud->font.glyph_width,
200 y + hud->font.glyph_height);
201
202 while (*s) {
203 unsigned x1 = x;
204 unsigned y1 = y;
205 unsigned x2 = x + hud->font.glyph_width;
206 unsigned y2 = y + hud->font.glyph_height;
207 unsigned tx1 = (*s % 16) * hud->font.glyph_width;
208 unsigned ty1 = (*s / 16) * hud->font.glyph_height;
209 unsigned tx2 = tx1 + hud->font.glyph_width;
210 unsigned ty2 = ty1 + hud->font.glyph_height;
211
212 if (*s == ' ') {
213 x += hud->font.glyph_width;
214 s++;
215 continue;
216 }
217
218 assert(hud->text.num_vertices + num/4 + 4 <= hud->text.max_num_vertices);
219
220 vertices[num++] = (float) x1;
221 vertices[num++] = (float) y1;
222 vertices[num++] = (float) tx1;
223 vertices[num++] = (float) ty1;
224
225 vertices[num++] = (float) x1;
226 vertices[num++] = (float) y2;
227 vertices[num++] = (float) tx1;
228 vertices[num++] = (float) ty2;
229
230 vertices[num++] = (float) x2;
231 vertices[num++] = (float) y2;
232 vertices[num++] = (float) tx2;
233 vertices[num++] = (float) ty2;
234
235 vertices[num++] = (float) x2;
236 vertices[num++] = (float) y1;
237 vertices[num++] = (float) tx2;
238 vertices[num++] = (float) ty1;
239
240 x += hud->font.glyph_width;
241 s++;
242 }
243
244 hud->text.num_vertices += num/4;
245 }
246
247 static void
248 number_to_human_readable(uint64_t num, enum pipe_driver_query_type type,
249 char *out)
250 {
251 static const char *byte_units[] =
252 {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
253 static const char *metric_units[] =
254 {"", " k", " M", " G", " T", " P", " E"};
255 static const char *time_units[] =
256 {" us", " ms", " s"}; /* based on microseconds */
257 static const char *hz_units[] =
258 {" Hz", " KHz", " MHz", " GHz"};
259 static const char *percent_units[] = {"%"};
260 static const char *dbm_units[] = {" (-dBm)"};
261 static const char *temperature_units[] = {" C"};
262 static const char *volt_units[] = {" mV", " V"};
263 static const char *amp_units[] = {" mA", " A"};
264 static const char *watt_units[] = {" mW", " W"};
265
266 const char **units;
267 unsigned max_unit;
268 double divisor = (type == PIPE_DRIVER_QUERY_TYPE_BYTES) ? 1024 : 1000;
269 unsigned unit = 0;
270 double d = num;
271
272 switch (type) {
273 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS:
274 max_unit = ARRAY_SIZE(time_units)-1;
275 units = time_units;
276 break;
277 case PIPE_DRIVER_QUERY_TYPE_VOLTS:
278 max_unit = ARRAY_SIZE(volt_units)-1;
279 units = volt_units;
280 break;
281 case PIPE_DRIVER_QUERY_TYPE_AMPS:
282 max_unit = ARRAY_SIZE(amp_units)-1;
283 units = amp_units;
284 break;
285 case PIPE_DRIVER_QUERY_TYPE_DBM:
286 max_unit = ARRAY_SIZE(dbm_units)-1;
287 units = dbm_units;
288 break;
289 case PIPE_DRIVER_QUERY_TYPE_TEMPERATURE:
290 max_unit = ARRAY_SIZE(temperature_units)-1;
291 units = temperature_units;
292 break;
293 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE:
294 max_unit = ARRAY_SIZE(percent_units)-1;
295 units = percent_units;
296 break;
297 case PIPE_DRIVER_QUERY_TYPE_BYTES:
298 max_unit = ARRAY_SIZE(byte_units)-1;
299 units = byte_units;
300 break;
301 case PIPE_DRIVER_QUERY_TYPE_HZ:
302 max_unit = ARRAY_SIZE(hz_units)-1;
303 units = hz_units;
304 break;
305 case PIPE_DRIVER_QUERY_TYPE_WATTS:
306 max_unit = ARRAY_SIZE(watt_units)-1;
307 units = watt_units;
308 break;
309 default:
310 max_unit = ARRAY_SIZE(metric_units)-1;
311 units = metric_units;
312 }
313
314 while (d > divisor && unit < max_unit) {
315 d /= divisor;
316 unit++;
317 }
318
319 /* Round to 3 decimal places so as not to print trailing zeros. */
320 if (d*1000 != (int)(d*1000))
321 d = round(d * 1000) / 1000;
322
323 /* Show at least 4 digits with at most 3 decimal places, but not zeros. */
324 if (d >= 1000 || d == (int)d)
325 sprintf(out, "%.0f%s", d, units[unit]);
326 else if (d >= 100 || d*10 == (int)(d*10))
327 sprintf(out, "%.1f%s", d, units[unit]);
328 else if (d >= 10 || d*100 == (int)(d*100))
329 sprintf(out, "%.2f%s", d, units[unit]);
330 else
331 sprintf(out, "%.3f%s", d, units[unit]);
332 }
333
334 static void
335 hud_draw_graph_line_strip(struct hud_context *hud, const struct hud_graph *gr,
336 unsigned xoffset, unsigned yoffset, float yscale)
337 {
338 if (gr->num_vertices <= 1)
339 return;
340
341 assert(gr->index <= gr->num_vertices);
342
343 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
344 gr->vertices, gr->index,
345 gr->color[0], gr->color[1], gr->color[2], 1,
346 xoffset + (gr->pane->max_num_vertices - gr->index - 1) * 2 - 1,
347 yoffset, yscale);
348
349 if (gr->num_vertices <= gr->index)
350 return;
351
352 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
353 gr->vertices + gr->index*2,
354 gr->num_vertices - gr->index,
355 gr->color[0], gr->color[1], gr->color[2], 1,
356 xoffset - gr->index*2 - 1, yoffset, yscale);
357 }
358
359 static void
360 hud_pane_accumulate_vertices(struct hud_context *hud,
361 const struct hud_pane *pane)
362 {
363 struct hud_graph *gr;
364 float *line_verts = hud->whitelines.vertices + hud->whitelines.num_vertices*2;
365 unsigned i, num = 0;
366 char str[32];
367 const unsigned last_line = pane->last_line;
368
369 /* draw background */
370 hud_draw_background_quad(hud,
371 pane->x1, pane->y1,
372 pane->x2, pane->y2);
373
374 /* draw numbers on the right-hand side */
375 for (i = 0; i <= last_line; i++) {
376 unsigned x = pane->x2 + 2;
377 unsigned y = pane->inner_y1 +
378 pane->inner_height * (last_line - i) / last_line -
379 hud->font.glyph_height / 2;
380
381 number_to_human_readable(pane->max_value * i / last_line,
382 pane->type, str);
383 hud_draw_string(hud, x, y, "%s", str);
384 }
385
386 /* draw info below the pane */
387 i = 0;
388 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
389 unsigned x = pane->x1 + 2;
390 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
391
392 number_to_human_readable(gr->current_value, pane->type, str);
393 hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
394 i++;
395 }
396
397 /* draw border */
398 assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices);
399 line_verts[num++] = (float) pane->x1;
400 line_verts[num++] = (float) pane->y1;
401 line_verts[num++] = (float) pane->x2;
402 line_verts[num++] = (float) pane->y1;
403
404 line_verts[num++] = (float) pane->x2;
405 line_verts[num++] = (float) pane->y1;
406 line_verts[num++] = (float) pane->x2;
407 line_verts[num++] = (float) pane->y2;
408
409 line_verts[num++] = (float) pane->x1;
410 line_verts[num++] = (float) pane->y2;
411 line_verts[num++] = (float) pane->x2;
412 line_verts[num++] = (float) pane->y2;
413
414 line_verts[num++] = (float) pane->x1;
415 line_verts[num++] = (float) pane->y1;
416 line_verts[num++] = (float) pane->x1;
417 line_verts[num++] = (float) pane->y2;
418
419 /* draw horizontal lines inside the graph */
420 for (i = 0; i <= last_line; i++) {
421 float y = round((pane->max_value * i / (double)last_line) *
422 pane->yscale + pane->inner_y2);
423
424 assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices);
425 line_verts[num++] = pane->x1;
426 line_verts[num++] = y;
427 line_verts[num++] = pane->x2;
428 line_verts[num++] = y;
429 }
430
431 hud->whitelines.num_vertices += num/2;
432 }
433
434 static void
435 hud_pane_draw_colored_objects(struct hud_context *hud,
436 const struct hud_pane *pane)
437 {
438 struct hud_graph *gr;
439 unsigned i;
440
441 /* draw colored quads below the pane */
442 i = 0;
443 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
444 unsigned x = pane->x1 + 2;
445 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
446
447 hud_draw_colored_quad(hud, PIPE_PRIM_QUADS, x + 1, y + 1, x + 12, y + 13,
448 gr->color[0], gr->color[1], gr->color[2], 1);
449 i++;
450 }
451
452 /* draw the line strips */
453 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
454 hud_draw_graph_line_strip(hud, gr, pane->inner_x1, pane->inner_y2, pane->yscale);
455 }
456 }
457
458 static void
459 hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v,
460 unsigned num_vertices, unsigned stride)
461 {
462 v->num_vertices = 0;
463 v->max_num_vertices = num_vertices;
464 v->vbuf.stride = stride;
465 u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices,
466 16, &v->vbuf.buffer_offset, &v->vbuf.buffer,
467 (void**)&v->vertices);
468 }
469
470 /**
471 * Draw the HUD to the texture \p tex.
472 * The texture is usually the back buffer being displayed.
473 */
474 void
475 hud_draw(struct hud_context *hud, struct pipe_resource *tex)
476 {
477 struct cso_context *cso = hud->cso;
478 struct pipe_context *pipe = hud->pipe;
479 struct pipe_framebuffer_state fb;
480 struct pipe_surface surf_templ, *surf;
481 struct pipe_viewport_state viewport;
482 const struct pipe_sampler_state *sampler_states[] =
483 { &hud->font_sampler_state };
484 struct hud_pane *pane;
485 struct hud_graph *gr;
486
487 if (!huds_visible)
488 return;
489
490 hud->fb_width = tex->width0;
491 hud->fb_height = tex->height0;
492 hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
493 hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
494
495 cso_save_state(cso, (CSO_BIT_FRAMEBUFFER |
496 CSO_BIT_SAMPLE_MASK |
497 CSO_BIT_MIN_SAMPLES |
498 CSO_BIT_BLEND |
499 CSO_BIT_DEPTH_STENCIL_ALPHA |
500 CSO_BIT_FRAGMENT_SHADER |
501 CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
502 CSO_BIT_FRAGMENT_SAMPLERS |
503 CSO_BIT_RASTERIZER |
504 CSO_BIT_VIEWPORT |
505 CSO_BIT_STREAM_OUTPUTS |
506 CSO_BIT_GEOMETRY_SHADER |
507 CSO_BIT_TESSCTRL_SHADER |
508 CSO_BIT_TESSEVAL_SHADER |
509 CSO_BIT_VERTEX_SHADER |
510 CSO_BIT_VERTEX_ELEMENTS |
511 CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
512 CSO_BIT_PAUSE_QUERIES |
513 CSO_BIT_RENDER_CONDITION));
514 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
515
516 /* set states */
517 memset(&surf_templ, 0, sizeof(surf_templ));
518 surf_templ.format = tex->format;
519
520 /* Without this, AA lines look thinner if they are between 2 pixels
521 * because the alpha is 0.5 on both pixels. (it's ugly)
522 *
523 * sRGB makes the width of all AA lines look the same.
524 */
525 if (hud->has_srgb) {
526 enum pipe_format srgb_format = util_format_srgb(tex->format);
527
528 if (srgb_format != PIPE_FORMAT_NONE)
529 surf_templ.format = srgb_format;
530 }
531 surf = pipe->create_surface(pipe, tex, &surf_templ);
532
533 memset(&fb, 0, sizeof(fb));
534 fb.nr_cbufs = 1;
535 fb.cbufs[0] = surf;
536 fb.zsbuf = NULL;
537 fb.width = hud->fb_width;
538 fb.height = hud->fb_height;
539
540 viewport.scale[0] = 0.5f * hud->fb_width;
541 viewport.scale[1] = 0.5f * hud->fb_height;
542 viewport.scale[2] = 1.0f;
543 viewport.translate[0] = 0.5f * hud->fb_width;
544 viewport.translate[1] = 0.5f * hud->fb_height;
545 viewport.translate[2] = 0.0f;
546
547 cso_set_framebuffer(cso, &fb);
548 cso_set_sample_mask(cso, ~0);
549 cso_set_min_samples(cso, 1);
550 cso_set_depth_stencil_alpha(cso, &hud->dsa);
551 cso_set_rasterizer(cso, &hud->rasterizer);
552 cso_set_viewport(cso, &viewport);
553 cso_set_stream_outputs(cso, 0, NULL, NULL);
554 cso_set_tessctrl_shader_handle(cso, NULL);
555 cso_set_tesseval_shader_handle(cso, NULL);
556 cso_set_geometry_shader_handle(cso, NULL);
557 cso_set_vertex_shader_handle(cso, hud->vs);
558 cso_set_vertex_elements(cso, 2, hud->velems);
559 cso_set_render_condition(cso, NULL, FALSE, 0);
560 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1,
561 &hud->font_sampler_view);
562 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states);
563 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
564
565 /* prepare vertex buffers */
566 hud_alloc_vertices(hud, &hud->bg, 4 * 256, 2 * sizeof(float));
567 hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float));
568 hud_alloc_vertices(hud, &hud->text, 4 * 1024, 4 * sizeof(float));
569
570 /* prepare all graphs */
571 hud_batch_query_update(hud->batch_query);
572
573 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
574 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
575 gr->query_new_value(gr);
576 }
577
578 hud_pane_accumulate_vertices(hud, pane);
579 }
580
581 /* unmap the uploader's vertex buffer before drawing */
582 u_upload_unmap(hud->uploader);
583
584 /* draw accumulated vertices for background quads */
585 cso_set_blend(cso, &hud->alpha_blend);
586 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
587
588 if (hud->bg.num_vertices) {
589 hud->constants.color[0] = 0;
590 hud->constants.color[1] = 0;
591 hud->constants.color[2] = 0;
592 hud->constants.color[3] = 0.666f;
593 hud->constants.translate[0] = 0;
594 hud->constants.translate[1] = 0;
595 hud->constants.scale[0] = 1;
596 hud->constants.scale[1] = 1;
597
598 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
599 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
600 &hud->bg.vbuf);
601 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->bg.num_vertices);
602 }
603 pipe_resource_reference(&hud->bg.vbuf.buffer, NULL);
604
605 /* draw accumulated vertices for white lines */
606 cso_set_blend(cso, &hud->no_blend);
607
608 hud->constants.color[0] = 1;
609 hud->constants.color[1] = 1;
610 hud->constants.color[2] = 1;
611 hud->constants.color[3] = 1;
612 hud->constants.translate[0] = 0;
613 hud->constants.translate[1] = 0;
614 hud->constants.scale[0] = 1;
615 hud->constants.scale[1] = 1;
616 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
617
618 if (hud->whitelines.num_vertices) {
619 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
620 &hud->whitelines.vbuf);
621 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
622 cso_draw_arrays(cso, PIPE_PRIM_LINES, 0, hud->whitelines.num_vertices);
623 }
624 pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL);
625
626 /* draw accumulated vertices for text */
627 cso_set_blend(cso, &hud->alpha_blend);
628 if (hud->text.num_vertices) {
629 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
630 &hud->text.vbuf);
631 cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
632 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->text.num_vertices);
633 }
634 pipe_resource_reference(&hud->text.vbuf.buffer, NULL);
635
636 /* draw the rest */
637 cso_set_rasterizer(cso, &hud->rasterizer_aa_lines);
638 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
639 if (pane)
640 hud_pane_draw_colored_objects(hud, pane);
641 }
642
643 cso_restore_state(cso);
644 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
645
646 pipe_surface_reference(&surf, NULL);
647 }
648
649 static void
650 fixup_bytes(enum pipe_driver_query_type type, int position, uint64_t *exp10)
651 {
652 if (type == PIPE_DRIVER_QUERY_TYPE_BYTES && position % 3 == 0)
653 *exp10 = (*exp10 / 1000) * 1024;
654 }
655
656 /**
657 * Set the maximum value for the Y axis of the graph.
658 * This scales the graph accordingly.
659 */
660 void
661 hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
662 {
663 double leftmost_digit;
664 uint64_t exp10;
665 int i;
666
667 /* The following code determines the max_value in the graph as well as
668 * how many describing lines are drawn. The max_value is rounded up,
669 * so that all drawn numbers are rounded for readability.
670 * We want to print multiples of a simple number instead of multiples of
671 * hard-to-read numbers like 1.753.
672 */
673
674 /* Find the left-most digit. */
675 exp10 = 1;
676 for (i = 0; value > 9 * exp10; i++) {
677 exp10 *= 10;
678 fixup_bytes(pane->type, i + 1, &exp10);
679 }
680
681 leftmost_digit = DIV_ROUND_UP(value, exp10);
682
683 /* Round 9 to 10. */
684 if (leftmost_digit == 9) {
685 leftmost_digit = 1;
686 exp10 *= 10;
687 fixup_bytes(pane->type, i + 1, &exp10);
688 }
689
690 switch ((unsigned)leftmost_digit) {
691 case 1:
692 pane->last_line = 5; /* lines in +1/5 increments */
693 break;
694 case 2:
695 pane->last_line = 8; /* lines in +1/4 increments. */
696 break;
697 case 3:
698 case 4:
699 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments */
700 break;
701 case 5:
702 case 6:
703 case 7:
704 case 8:
705 pane->last_line = leftmost_digit; /* lines in +1 increments */
706 break;
707 default:
708 assert(0);
709 }
710
711 /* Truncate {3,4} to {2.5, 3.5} if possible. */
712 for (i = 3; i <= 4; i++) {
713 if (leftmost_digit == i && value <= (i - 0.5) * exp10) {
714 leftmost_digit = i - 0.5;
715 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments. */
716 }
717 }
718
719 /* Truncate 2 to a multiple of 0.2 in (1, 1.6] if possible. */
720 if (leftmost_digit == 2) {
721 for (i = 1; i <= 3; i++) {
722 if (value <= (1 + i*0.2) * exp10) {
723 leftmost_digit = 1 + i*0.2;
724 pane->last_line = 5 + i; /* lines in +1/5 increments. */
725 break;
726 }
727 }
728 }
729
730 pane->max_value = leftmost_digit * exp10;
731 pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
732 }
733
734 static void
735 hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane)
736 {
737 unsigned i;
738 float tmp = 0.0f;
739
740 if (pane->dyn_ceil_last_ran != gr->index) {
741 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
742 for (i = 0; i < gr->num_vertices; ++i) {
743 tmp = gr->vertices[i * 2 + 1] > tmp ?
744 gr->vertices[i * 2 + 1] : tmp;
745 }
746 }
747
748 /* Avoid setting it lower than the initial starting height. */
749 tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value;
750 hud_pane_set_max_value(pane, tmp);
751 }
752
753 /*
754 * Mark this adjustment run so we could avoid repeating a full update
755 * again needlessly in case the pane has more than one graph.
756 */
757 pane->dyn_ceil_last_ran = gr->index;
758 }
759
760 static struct hud_pane *
761 hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
762 unsigned period, uint64_t max_value, uint64_t ceiling,
763 boolean dyn_ceiling)
764 {
765 struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
766
767 if (!pane)
768 return NULL;
769
770 pane->x1 = x1;
771 pane->y1 = y1;
772 pane->x2 = x2;
773 pane->y2 = y2;
774 pane->inner_x1 = x1 + 1;
775 pane->inner_x2 = x2 - 1;
776 pane->inner_y1 = y1 + 1;
777 pane->inner_y2 = y2 - 1;
778 pane->inner_width = pane->inner_x2 - pane->inner_x1;
779 pane->inner_height = pane->inner_y2 - pane->inner_y1;
780 pane->period = period;
781 pane->max_num_vertices = (x2 - x1 + 2) / 2;
782 pane->ceiling = ceiling;
783 pane->dyn_ceiling = dyn_ceiling;
784 pane->dyn_ceil_last_ran = 0;
785 pane->initial_max_value = max_value;
786 hud_pane_set_max_value(pane, max_value);
787 LIST_INITHEAD(&pane->graph_list);
788 return pane;
789 }
790
791 /**
792 * Add a graph to an existing pane.
793 * One pane can contain multiple graphs over each other.
794 */
795 void
796 hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr)
797 {
798 static const float colors[][3] = {
799 {0, 1, 0},
800 {1, 0, 0},
801 {0, 1, 1},
802 {1, 0, 1},
803 {1, 1, 0},
804 {0.5, 0.5, 1},
805 {0.5, 0.5, 0.5},
806 };
807 char *name = gr->name;
808
809 /* replace '-' with a space */
810 while (*name) {
811 if (*name == '-')
812 *name = ' ';
813 name++;
814 }
815
816 assert(pane->num_graphs < ARRAY_SIZE(colors));
817 gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2);
818 gr->color[0] = colors[pane->num_graphs][0];
819 gr->color[1] = colors[pane->num_graphs][1];
820 gr->color[2] = colors[pane->num_graphs][2];
821 gr->pane = pane;
822 LIST_ADDTAIL(&gr->head, &pane->graph_list);
823 pane->num_graphs++;
824 }
825
826 void
827 hud_graph_add_value(struct hud_graph *gr, uint64_t value)
828 {
829 gr->current_value = value;
830 value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
831
832 if (gr->index == gr->pane->max_num_vertices) {
833 gr->vertices[0] = 0;
834 gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
835 gr->index = 1;
836 }
837 gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2);
838 gr->vertices[(gr->index)*2+1] = (float) value;
839 gr->index++;
840
841 if (gr->num_vertices < gr->pane->max_num_vertices) {
842 gr->num_vertices++;
843 }
844
845 if (gr->pane->dyn_ceiling == true) {
846 hud_pane_update_dyn_ceiling(gr, gr->pane);
847 }
848 if (value > gr->pane->max_value) {
849 hud_pane_set_max_value(gr->pane, value);
850 }
851 }
852
853 static void
854 hud_graph_destroy(struct hud_graph *graph)
855 {
856 FREE(graph->vertices);
857 if (graph->free_query_data)
858 graph->free_query_data(graph->query_data);
859 FREE(graph);
860 }
861
862 /**
863 * Read a string from the environment variable.
864 * The separators "+", ",", ":", and ";" terminate the string.
865 * Return the number of read characters.
866 */
867 static int
868 parse_string(const char *s, char *out)
869 {
870 int i;
871
872 for (i = 0; *s && *s != '+' && *s != ',' && *s != ':' && *s != ';';
873 s++, out++, i++)
874 *out = *s;
875
876 *out = 0;
877
878 if (*s && !i) {
879 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
880 "parsing a string\n", *s, *s);
881 fflush(stderr);
882 }
883
884 return i;
885 }
886
887 static char *
888 read_pane_settings(char *str, unsigned * const x, unsigned * const y,
889 unsigned * const width, unsigned * const height,
890 uint64_t * const ceiling, boolean * const dyn_ceiling)
891 {
892 char *ret = str;
893 unsigned tmp;
894
895 while (*str == '.') {
896 ++str;
897 switch (*str) {
898 case 'x':
899 ++str;
900 *x = strtoul(str, &ret, 10);
901 str = ret;
902 break;
903
904 case 'y':
905 ++str;
906 *y = strtoul(str, &ret, 10);
907 str = ret;
908 break;
909
910 case 'w':
911 ++str;
912 tmp = strtoul(str, &ret, 10);
913 *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */
914 str = ret;
915 break;
916
917 /*
918 * Prevent setting height to less than 50. If the height is set to less,
919 * the text of the Y axis labels on the graph will start overlapping.
920 */
921 case 'h':
922 ++str;
923 tmp = strtoul(str, &ret, 10);
924 *height = tmp > 50 ? tmp : 50;
925 str = ret;
926 break;
927
928 case 'c':
929 ++str;
930 tmp = strtoul(str, &ret, 10);
931 *ceiling = tmp > 10 ? tmp : 10;
932 str = ret;
933 break;
934
935 case 'd':
936 ++str;
937 ret = str;
938 *dyn_ceiling = true;
939 break;
940
941 default:
942 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
943 fflush(stderr);
944 }
945
946 }
947
948 return ret;
949 }
950
951 static boolean
952 has_occlusion_query(struct pipe_screen *screen)
953 {
954 return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
955 }
956
957 static boolean
958 has_streamout(struct pipe_screen *screen)
959 {
960 return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
961 }
962
963 static boolean
964 has_pipeline_stats_query(struct pipe_screen *screen)
965 {
966 return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
967 }
968
969 static void
970 hud_parse_env_var(struct hud_context *hud, const char *env)
971 {
972 unsigned num, i;
973 char name_a[256], s[256];
974 char *name;
975 struct hud_pane *pane = NULL;
976 unsigned x = 10, y = 10;
977 unsigned width = 251, height = 100;
978 unsigned period = 500 * 1000; /* default period (1/2 second) */
979 uint64_t ceiling = UINT64_MAX;
980 unsigned column_width = 251;
981 boolean dyn_ceiling = false;
982 const char *period_env;
983
984 /*
985 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
986 * The env var is in seconds (a float).
987 * Zero means update after every frame.
988 */
989 period_env = getenv("GALLIUM_HUD_PERIOD");
990 if (period_env) {
991 float p = (float) atof(period_env);
992 if (p >= 0.0f) {
993 period = (unsigned) (p * 1000 * 1000);
994 }
995 }
996
997 while ((num = parse_string(env, name_a)) != 0) {
998 env += num;
999
1000 /* check for explicit location, size and etc. settings */
1001 name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling,
1002 &dyn_ceiling);
1003
1004 /*
1005 * Keep track of overall column width to avoid pane overlapping in case
1006 * later we create a new column while the bottom pane in the current
1007 * column is less wide than the rest of the panes in it.
1008 */
1009 column_width = width > column_width ? width : column_width;
1010
1011 if (!pane) {
1012 pane = hud_pane_create(x, y, x + width, y + height, period, 10,
1013 ceiling, dyn_ceiling);
1014 if (!pane)
1015 return;
1016 }
1017
1018 /* Add a graph. */
1019 #if HAVE_GALLIUM_EXTRA_HUD || HAVE_LIBSENSORS
1020 char arg_name[64];
1021 #endif
1022 /* IF YOU CHANGE THIS, UPDATE print_help! */
1023 if (strcmp(name, "fps") == 0) {
1024 hud_fps_graph_install(pane);
1025 }
1026 else if (strcmp(name, "cpu") == 0) {
1027 hud_cpu_graph_install(pane, ALL_CPUS);
1028 }
1029 else if (sscanf(name, "cpu%u%s", &i, s) == 1) {
1030 hud_cpu_graph_install(pane, i);
1031 }
1032 #if HAVE_GALLIUM_EXTRA_HUD
1033 else if (sscanf(name, "nic-rx-%s", arg_name) == 1) {
1034 hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_RX);
1035 }
1036 else if (sscanf(name, "nic-tx-%s", arg_name) == 1) {
1037 hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_TX);
1038 }
1039 else if (sscanf(name, "nic-rssi-%s", arg_name) == 1) {
1040 hud_nic_graph_install(pane, arg_name, NIC_RSSI_DBM);
1041 pane->type = PIPE_DRIVER_QUERY_TYPE_DBM;
1042 }
1043 else if (sscanf(name, "diskstat-rd-%s", arg_name) == 1) {
1044 hud_diskstat_graph_install(pane, arg_name, DISKSTAT_RD);
1045 pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES;
1046 }
1047 else if (sscanf(name, "diskstat-wr-%s", arg_name) == 1) {
1048 hud_diskstat_graph_install(pane, arg_name, DISKSTAT_WR);
1049 pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES;
1050 }
1051 else if (sscanf(name, "cpufreq-min-cpu%u", &i) == 1) {
1052 hud_cpufreq_graph_install(pane, i, CPUFREQ_MINIMUM);
1053 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1054 }
1055 else if (sscanf(name, "cpufreq-cur-cpu%u", &i) == 1) {
1056 hud_cpufreq_graph_install(pane, i, CPUFREQ_CURRENT);
1057 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1058 }
1059 else if (sscanf(name, "cpufreq-max-cpu%u", &i) == 1) {
1060 hud_cpufreq_graph_install(pane, i, CPUFREQ_MAXIMUM);
1061 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1062 }
1063 #endif
1064 #if HAVE_LIBSENSORS
1065 else if (sscanf(name, "sensors_temp_cu-%s", arg_name) == 1) {
1066 hud_sensors_temp_graph_install(pane, arg_name,
1067 SENSORS_TEMP_CURRENT);
1068 pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE;
1069 }
1070 else if (sscanf(name, "sensors_temp_cr-%s", arg_name) == 1) {
1071 hud_sensors_temp_graph_install(pane, arg_name,
1072 SENSORS_TEMP_CRITICAL);
1073 pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE;
1074 }
1075 else if (sscanf(name, "sensors_volt_cu-%s", arg_name) == 1) {
1076 hud_sensors_temp_graph_install(pane, arg_name,
1077 SENSORS_VOLTAGE_CURRENT);
1078 pane->type = PIPE_DRIVER_QUERY_TYPE_VOLTS;
1079 }
1080 else if (sscanf(name, "sensors_curr_cu-%s", arg_name) == 1) {
1081 hud_sensors_temp_graph_install(pane, arg_name,
1082 SENSORS_CURRENT_CURRENT);
1083 pane->type = PIPE_DRIVER_QUERY_TYPE_AMPS;
1084 }
1085 else if (sscanf(name, "sensors_pow_cu-%s", arg_name) == 1) {
1086 hud_sensors_temp_graph_install(pane, arg_name,
1087 SENSORS_POWER_CURRENT);
1088 pane->type = PIPE_DRIVER_QUERY_TYPE_WATTS;
1089 }
1090 #endif
1091 else if (strcmp(name, "samples-passed") == 0 &&
1092 has_occlusion_query(hud->pipe->screen)) {
1093 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1094 "samples-passed",
1095 PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
1096 PIPE_DRIVER_QUERY_TYPE_UINT64,
1097 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1098 0);
1099 }
1100 else if (strcmp(name, "primitives-generated") == 0 &&
1101 has_streamout(hud->pipe->screen)) {
1102 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1103 "primitives-generated",
1104 PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
1105 PIPE_DRIVER_QUERY_TYPE_UINT64,
1106 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1107 0);
1108 }
1109 else {
1110 boolean processed = FALSE;
1111
1112 /* pipeline statistics queries */
1113 if (has_pipeline_stats_query(hud->pipe->screen)) {
1114 static const char *pipeline_statistics_names[] =
1115 {
1116 "ia-vertices",
1117 "ia-primitives",
1118 "vs-invocations",
1119 "gs-invocations",
1120 "gs-primitives",
1121 "clipper-invocations",
1122 "clipper-primitives-generated",
1123 "ps-invocations",
1124 "hs-invocations",
1125 "ds-invocations",
1126 "cs-invocations"
1127 };
1128 for (i = 0; i < ARRAY_SIZE(pipeline_statistics_names); ++i)
1129 if (strcmp(name, pipeline_statistics_names[i]) == 0)
1130 break;
1131 if (i < ARRAY_SIZE(pipeline_statistics_names)) {
1132 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name,
1133 PIPE_QUERY_PIPELINE_STATISTICS, i,
1134 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
1135 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1136 0);
1137 processed = TRUE;
1138 }
1139 }
1140
1141 /* driver queries */
1142 if (!processed) {
1143 if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe,
1144 name)) {
1145 fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
1146 fflush(stderr);
1147 }
1148 }
1149 }
1150
1151 if (*env == ':') {
1152 env++;
1153
1154 if (!pane) {
1155 fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
1156 "expected a name\n");
1157 fflush(stderr);
1158 break;
1159 }
1160
1161 num = parse_string(env, s);
1162 env += num;
1163
1164 if (num && sscanf(s, "%u", &i) == 1) {
1165 hud_pane_set_max_value(pane, i);
1166 pane->initial_max_value = i;
1167 }
1168 else {
1169 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
1170 "after ':'\n", *env, *env);
1171 fflush(stderr);
1172 }
1173 }
1174
1175 if (*env == 0)
1176 break;
1177
1178 /* parse a separator */
1179 switch (*env) {
1180 case '+':
1181 env++;
1182 break;
1183
1184 case ',':
1185 env++;
1186 if (!pane)
1187 break;
1188
1189 y += height + hud->font.glyph_height * (pane->num_graphs + 2);
1190 height = 100;
1191
1192 if (pane && pane->num_graphs) {
1193 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1194 pane = NULL;
1195 }
1196 break;
1197
1198 case ';':
1199 env++;
1200 y = 10;
1201 x += column_width + hud->font.glyph_width * 9;
1202 height = 100;
1203
1204 if (pane && pane->num_graphs) {
1205 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1206 pane = NULL;
1207 }
1208
1209 /* Starting a new column; reset column width. */
1210 column_width = 251;
1211 break;
1212
1213 default:
1214 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
1215 fflush(stderr);
1216 }
1217
1218 /* Reset to defaults for the next pane in case these were modified. */
1219 width = 251;
1220 ceiling = UINT64_MAX;
1221 dyn_ceiling = false;
1222
1223 }
1224
1225 if (pane) {
1226 if (pane->num_graphs) {
1227 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1228 }
1229 else {
1230 FREE(pane);
1231 }
1232 }
1233 }
1234
1235 static void
1236 print_help(struct pipe_screen *screen)
1237 {
1238 int i, num_queries, num_cpus = hud_get_num_cpus();
1239
1240 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1241 puts("");
1242 puts(" Names are identifiers of data sources which will be drawn as graphs");
1243 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1244 puts(" There can be multiple panes placed in rows and columns.");
1245 puts("");
1246 puts(" '+' separates names which will share a pane.");
1247 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1248 puts(" for the given pane.");
1249 puts(" ',' creates a new pane below the last one.");
1250 puts(" ';' creates a new pane at the top of the next column.");
1251 puts("");
1252 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1253 puts("");
1254 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1255 puts(" a name, it is possible to explicitly set the location and size");
1256 puts(" of a pane, along with limiting overall maximum value of the");
1257 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1258 puts(" Several modifiers may be applied to the same pane simultaneously.");
1259 puts("");
1260 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1261 puts(" to the upper-left corner of the viewport, in pixels.");
1262 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1263 puts(" to the upper-left corner of the viewport, in pixels.");
1264 puts(" 'w[value]' sets width of the graph pixels.");
1265 puts(" 'h[value]' sets height of the graph in pixels.");
1266 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1267 puts(" If the graph needs to draw values higher than");
1268 puts(" the ceiling allows, the value is clamped.");
1269 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1270 puts(" the Y axis to match the highest value still visible in the graph.");
1271 puts("");
1272 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1273 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1274 puts(" still adjusting the value of the Y axis down when appropriate.");
1275 puts("");
1276 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1277 puts("");
1278 puts(" Available names:");
1279 puts(" fps");
1280 puts(" cpu");
1281
1282 for (i = 0; i < num_cpus; i++)
1283 printf(" cpu%i\n", i);
1284
1285 if (has_occlusion_query(screen))
1286 puts(" samples-passed");
1287 if (has_streamout(screen))
1288 puts(" primitives-generated");
1289
1290 if (has_pipeline_stats_query(screen)) {
1291 puts(" ia-vertices");
1292 puts(" ia-primitives");
1293 puts(" vs-invocations");
1294 puts(" gs-invocations");
1295 puts(" gs-primitives");
1296 puts(" clipper-invocations");
1297 puts(" clipper-primitives-generated");
1298 puts(" ps-invocations");
1299 puts(" hs-invocations");
1300 puts(" ds-invocations");
1301 puts(" cs-invocations");
1302 }
1303
1304 #if HAVE_GALLIUM_EXTRA_HUD
1305 hud_get_num_disks(1);
1306 hud_get_num_nics(1);
1307 hud_get_num_cpufreq(1);
1308 #endif
1309 #if HAVE_LIBSENSORS
1310 hud_get_num_sensors(1);
1311 #endif
1312
1313 if (screen->get_driver_query_info){
1314 boolean skipping = false;
1315 struct pipe_driver_query_info info;
1316 num_queries = screen->get_driver_query_info(screen, 0, NULL);
1317
1318 for (i = 0; i < num_queries; i++){
1319 screen->get_driver_query_info(screen, i, &info);
1320 if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) {
1321 if (!skipping)
1322 puts(" ...");
1323 skipping = true;
1324 } else {
1325 printf(" %s\n", info.name);
1326 skipping = false;
1327 }
1328 }
1329 }
1330
1331 puts("");
1332 fflush(stdout);
1333 }
1334
1335 struct hud_context *
1336 hud_create(struct pipe_context *pipe, struct cso_context *cso)
1337 {
1338 struct pipe_screen *screen = pipe->screen;
1339 struct hud_context *hud;
1340 struct pipe_sampler_view view_templ;
1341 unsigned i;
1342 const char *env = debug_get_option("GALLIUM_HUD", NULL);
1343 #ifdef PIPE_OS_UNIX
1344 unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
1345 static boolean sig_handled = FALSE;
1346 struct sigaction action = {};
1347 #endif
1348 huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
1349
1350 if (!env || !*env)
1351 return NULL;
1352
1353 if (strcmp(env, "help") == 0) {
1354 print_help(pipe->screen);
1355 return NULL;
1356 }
1357
1358 hud = CALLOC_STRUCT(hud_context);
1359 if (!hud)
1360 return NULL;
1361
1362 hud->pipe = pipe;
1363 hud->cso = cso;
1364 hud->uploader = u_upload_create(pipe, 256 * 1024,
1365 PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_STREAM);
1366
1367 /* font */
1368 if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) {
1369 u_upload_destroy(hud->uploader);
1370 FREE(hud);
1371 return NULL;
1372 }
1373
1374 hud->has_srgb = screen->is_format_supported(screen,
1375 PIPE_FORMAT_B8G8R8A8_SRGB,
1376 PIPE_TEXTURE_2D, 0,
1377 PIPE_BIND_RENDER_TARGET) != 0;
1378
1379 /* blend state */
1380 hud->no_blend.rt[0].colormask = PIPE_MASK_RGBA;
1381
1382 hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA;
1383 hud->alpha_blend.rt[0].blend_enable = 1;
1384 hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD;
1385 hud->alpha_blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
1386 hud->alpha_blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
1387 hud->alpha_blend.rt[0].alpha_func = PIPE_BLEND_ADD;
1388 hud->alpha_blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
1389 hud->alpha_blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
1390
1391 /* fragment shader */
1392 hud->fs_color =
1393 util_make_fragment_passthrough_shader(pipe,
1394 TGSI_SEMANTIC_COLOR,
1395 TGSI_INTERPOLATE_CONSTANT,
1396 TRUE);
1397
1398 {
1399 /* Read a texture and do .xxxx swizzling. */
1400 static const char *fragment_shader_text = {
1401 "FRAG\n"
1402 "DCL IN[0], GENERIC[0], LINEAR\n"
1403 "DCL SAMP[0]\n"
1404 "DCL SVIEW[0], RECT, FLOAT\n"
1405 "DCL OUT[0], COLOR[0]\n"
1406 "DCL TEMP[0]\n"
1407
1408 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1409 "MOV OUT[0], TEMP[0].xxxx\n"
1410 "END\n"
1411 };
1412
1413 struct tgsi_token tokens[1000];
1414 struct pipe_shader_state state;
1415
1416 if (!tgsi_text_translate(fragment_shader_text, tokens, ARRAY_SIZE(tokens))) {
1417 assert(0);
1418 pipe_resource_reference(&hud->font.texture, NULL);
1419 u_upload_destroy(hud->uploader);
1420 FREE(hud);
1421 return NULL;
1422 }
1423 pipe_shader_state_from_tgsi(&state, tokens);
1424 hud->fs_text = pipe->create_fs_state(pipe, &state);
1425 }
1426
1427 /* rasterizer */
1428 hud->rasterizer.half_pixel_center = 1;
1429 hud->rasterizer.bottom_edge_rule = 1;
1430 hud->rasterizer.depth_clip = 1;
1431 hud->rasterizer.line_width = 1;
1432 hud->rasterizer.line_last_pixel = 1;
1433
1434 hud->rasterizer_aa_lines = hud->rasterizer;
1435 hud->rasterizer_aa_lines.line_smooth = 1;
1436
1437 /* vertex shader */
1438 {
1439 static const char *vertex_shader_text = {
1440 "VERT\n"
1441 "DCL IN[0..1]\n"
1442 "DCL OUT[0], POSITION\n"
1443 "DCL OUT[1], COLOR[0]\n" /* color */
1444 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1445 /* [0] = color,
1446 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1447 * [2] = (xscale, yscale, 0, 0) */
1448 "DCL CONST[0..2]\n"
1449 "DCL TEMP[0]\n"
1450 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1451
1452 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1453 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1454 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1455 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1456 "MOV OUT[0].zw, IMM[0]\n"
1457
1458 "MOV OUT[1], CONST[0]\n"
1459 "MOV OUT[2], IN[1]\n"
1460 "END\n"
1461 };
1462
1463 struct tgsi_token tokens[1000];
1464 struct pipe_shader_state state;
1465 if (!tgsi_text_translate(vertex_shader_text, tokens, ARRAY_SIZE(tokens))) {
1466 assert(0);
1467 pipe_resource_reference(&hud->font.texture, NULL);
1468 u_upload_destroy(hud->uploader);
1469 FREE(hud);
1470 return NULL;
1471 }
1472 pipe_shader_state_from_tgsi(&state, tokens);
1473 hud->vs = pipe->create_vs_state(pipe, &state);
1474 }
1475
1476 /* vertex elements */
1477 for (i = 0; i < 2; i++) {
1478 hud->velems[i].src_offset = i * 2 * sizeof(float);
1479 hud->velems[i].src_format = PIPE_FORMAT_R32G32_FLOAT;
1480 hud->velems[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1481 }
1482
1483 /* sampler view */
1484 u_sampler_view_default_template(
1485 &view_templ, hud->font.texture, hud->font.texture->format);
1486 hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
1487 &view_templ);
1488
1489 /* sampler state (for font drawing) */
1490 hud->font_sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1491 hud->font_sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1492 hud->font_sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1493 hud->font_sampler_state.normalized_coords = 0;
1494
1495 /* constants */
1496 hud->constbuf.buffer_size = sizeof(hud->constants);
1497 hud->constbuf.user_buffer = &hud->constants;
1498
1499 LIST_INITHEAD(&hud->pane_list);
1500
1501 /* setup sig handler once for all hud contexts */
1502 #ifdef PIPE_OS_UNIX
1503 if (!sig_handled && signo != 0) {
1504 action.sa_sigaction = &signal_visible_handler;
1505 action.sa_flags = SA_SIGINFO;
1506
1507 if (signo >= NSIG)
1508 fprintf(stderr, "gallium_hud: invalid signal %u\n", signo);
1509 else if (sigaction(signo, &action, NULL) < 0)
1510 fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo);
1511 fflush(stderr);
1512
1513 sig_handled = TRUE;
1514 }
1515 #endif
1516
1517 hud_parse_env_var(hud, env);
1518 return hud;
1519 }
1520
1521 void
1522 hud_destroy(struct hud_context *hud)
1523 {
1524 struct pipe_context *pipe = hud->pipe;
1525 struct hud_pane *pane, *pane_tmp;
1526 struct hud_graph *graph, *graph_tmp;
1527
1528 LIST_FOR_EACH_ENTRY_SAFE(pane, pane_tmp, &hud->pane_list, head) {
1529 LIST_FOR_EACH_ENTRY_SAFE(graph, graph_tmp, &pane->graph_list, head) {
1530 LIST_DEL(&graph->head);
1531 hud_graph_destroy(graph);
1532 }
1533 LIST_DEL(&pane->head);
1534 FREE(pane);
1535 }
1536
1537 hud_batch_query_cleanup(&hud->batch_query);
1538 pipe->delete_fs_state(pipe, hud->fs_color);
1539 pipe->delete_fs_state(pipe, hud->fs_text);
1540 pipe->delete_vs_state(pipe, hud->vs);
1541 pipe_sampler_view_reference(&hud->font_sampler_view, NULL);
1542 pipe_resource_reference(&hud->font.texture, NULL);
1543 u_upload_destroy(hud->uploader);
1544 FREE(hud);
1545 }