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