X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fauxiliary%2Fhud%2Fhud_context.c;h=a82cdf273e06b7b30d6c079feb1b108b40023118;hb=8c60bcb4c317026e017a8ecffe303fd4e7f0db33;hp=5ba80a15ac38324ad5c26ada02020e2b7be352d8;hpb=332af88c391924c70bbcbeb4c131caea796534f6;p=mesa.git diff --git a/src/gallium/auxiliary/hud/hud_context.c b/src/gallium/auxiliary/hud/hud_context.c index 5ba80a15ac3..a82cdf273e0 100644 --- a/src/gallium/auxiliary/hud/hud_context.c +++ b/src/gallium/auxiliary/hud/hud_context.c @@ -33,34 +33,42 @@ * Set GALLIUM_HUD=help for more info. */ +#include +#include + #include "hud/hud_context.h" #include "hud/hud_private.h" #include "hud/font.h" #include "cso_cache/cso_context.h" #include "util/u_draw_quad.h" +#include "util/u_format.h" #include "util/u_inlines.h" #include "util/u_memory.h" #include "util/u_math.h" +#include "util/u_sampler.h" #include "util/u_simple_shaders.h" #include "util/u_string.h" #include "util/u_upload_mgr.h" #include "tgsi/tgsi_text.h" #include "tgsi/tgsi_dump.h" +/* Control the visibility of all HUD contexts */ +static boolean huds_visible = TRUE; struct hud_context { struct pipe_context *pipe; struct cso_context *cso; struct u_upload_mgr *uploader; + struct hud_batch_query_context *batch_query; struct list_head pane_list; /* states */ - struct pipe_blend_state alpha_blend; + struct pipe_blend_state no_blend, alpha_blend; struct pipe_depth_stencil_alpha_state dsa; void *fs_color, *fs_text; - struct pipe_rasterizer_state rasterizer; + struct pipe_rasterizer_state rasterizer, rasterizer_aa_lines; void *vs; struct pipe_vertex_element velems[2]; @@ -90,8 +98,17 @@ struct hud_context { unsigned max_num_vertices; unsigned num_vertices; } text, bg, whitelines; + + bool has_srgb; }; +#ifdef PIPE_OS_UNIX +static void +signal_visible_handler(int sig, siginfo_t *siginfo, void *context) +{ + huds_visible = !huds_visible; +} +#endif static void hud_draw_colored_prims(struct hud_context *hud, unsigned prim, @@ -106,8 +123,8 @@ hud_draw_colored_prims(struct hud_context *hud, unsigned prim, hud->constants.color[1] = g; hud->constants.color[2] = b; hud->constants.color[3] = a; - hud->constants.translate[0] = xoffset; - hud->constants.translate[1] = yoffset; + hud->constants.translate[0] = (float) xoffset; + hud->constants.translate[1] = (float) yoffset; hud->constants.scale[0] = 1; hud->constants.scale[1] = yscale; cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf); @@ -127,10 +144,10 @@ hud_draw_colored_quad(struct hud_context *hud, unsigned prim, float r, float g, float b, float a) { float buffer[] = { - x1, y1, - x1, y2, - x2, y2, - x2, y1, + (float) x1, (float) y1, + (float) x1, (float) y2, + (float) x2, (float) y2, + (float) x2, (float) y1, }; hud_draw_colored_prims(hud, prim, buffer, 4, r, g, b, a, 0, 0, 1); @@ -145,17 +162,17 @@ hud_draw_background_quad(struct hud_context *hud, assert(hud->bg.num_vertices + 4 <= hud->bg.max_num_vertices); - vertices[num++] = x1; - vertices[num++] = y1; + vertices[num++] = (float) x1; + vertices[num++] = (float) y1; - vertices[num++] = x1; - vertices[num++] = y2; + vertices[num++] = (float) x1; + vertices[num++] = (float) y2; - vertices[num++] = x2; - vertices[num++] = y2; + vertices[num++] = (float) x2; + vertices[num++] = (float) y2; - vertices[num++] = x2; - vertices[num++] = y1; + vertices[num++] = (float) x2; + vertices[num++] = (float) y1; hud->bg.num_vertices += num/2; } @@ -200,25 +217,25 @@ hud_draw_string(struct hud_context *hud, unsigned x, unsigned y, assert(hud->text.num_vertices + num/4 + 4 <= hud->text.max_num_vertices); - vertices[num++] = x1; - vertices[num++] = y1; - vertices[num++] = tx1; - vertices[num++] = ty1; + vertices[num++] = (float) x1; + vertices[num++] = (float) y1; + vertices[num++] = (float) tx1; + vertices[num++] = (float) ty1; - vertices[num++] = x1; - vertices[num++] = y2; - vertices[num++] = tx1; - vertices[num++] = ty2; + vertices[num++] = (float) x1; + vertices[num++] = (float) y2; + vertices[num++] = (float) tx1; + vertices[num++] = (float) ty2; - vertices[num++] = x2; - vertices[num++] = y2; - vertices[num++] = tx2; - vertices[num++] = ty2; + vertices[num++] = (float) x2; + vertices[num++] = (float) y2; + vertices[num++] = (float) tx2; + vertices[num++] = (float) ty2; - vertices[num++] = x2; - vertices[num++] = y1; - vertices[num++] = tx2; - vertices[num++] = ty1; + vertices[num++] = (float) x2; + vertices[num++] = (float) y1; + vertices[num++] = (float) tx2; + vertices[num++] = (float) ty1; x += hud->font.glyph_width; s++; @@ -228,28 +245,90 @@ hud_draw_string(struct hud_context *hud, unsigned x, unsigned y, } static void -number_to_human_readable(uint64_t num, boolean is_in_bytes, char *out) +number_to_human_readable(uint64_t num, uint64_t max_value, + enum pipe_driver_query_type type, char *out) { static const char *byte_units[] = - {"", " KB", " MB", " GB", " TB", " PB", " EB"}; + {" B", " KB", " MB", " GB", " TB", " PB", " EB"}; static const char *metric_units[] = {"", " k", " M", " G", " T", " P", " E"}; - const char **units = is_in_bytes ? byte_units : metric_units; - double divisor = is_in_bytes ? 1024 : 1000; - int unit = 0; + static const char *time_units[] = + {" us", " ms", " s"}; /* based on microseconds */ + static const char *hz_units[] = + {" Hz", " KHz", " MHz", " GHz"}; + static const char *percent_units[] = {"%"}; + static const char *dbm_units[] = {" (-dBm)"}; + static const char *temperature_units[] = {" C"}; + static const char *volt_units[] = {" mV", " V"}; + static const char *amp_units[] = {" mA", " A"}; + + const char **units; + unsigned max_unit; + double divisor = (type == PIPE_DRIVER_QUERY_TYPE_BYTES) ? 1024 : 1000; + unsigned unit = 0; double d = num; - while (d > divisor) { + switch (type) { + case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS: + max_unit = ARRAY_SIZE(time_units)-1; + units = time_units; + break; + case PIPE_DRIVER_QUERY_TYPE_VOLTS: + max_unit = ARRAY_SIZE(volt_units)-1; + units = volt_units; + break; + case PIPE_DRIVER_QUERY_TYPE_AMPS: + max_unit = ARRAY_SIZE(amp_units)-1; + units = amp_units; + break; + case PIPE_DRIVER_QUERY_TYPE_DBM: + max_unit = ARRAY_SIZE(dbm_units)-1; + units = dbm_units; + break; + case PIPE_DRIVER_QUERY_TYPE_TEMPERATURE: + max_unit = ARRAY_SIZE(temperature_units)-1; + units = temperature_units; + break; + case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE: + max_unit = ARRAY_SIZE(percent_units)-1; + units = percent_units; + break; + case PIPE_DRIVER_QUERY_TYPE_BYTES: + max_unit = ARRAY_SIZE(byte_units)-1; + units = byte_units; + break; + case PIPE_DRIVER_QUERY_TYPE_HZ: + max_unit = ARRAY_SIZE(hz_units)-1; + units = hz_units; + break; + default: + if (max_value == 100) { + max_unit = ARRAY_SIZE(percent_units)-1; + units = percent_units; + } else { + max_unit = ARRAY_SIZE(metric_units)-1; + units = metric_units; + } + } + + while (d > divisor && unit < max_unit) { d /= divisor; unit++; } - if (d >= 100 || d == (int)d) + /* Round to 3 decimal places so as not to print trailing zeros. */ + if (d*1000 != (int)(d*1000)) + d = round(d * 1000) / 1000; + + /* Show at least 4 digits with at most 3 decimal places, but not zeros. */ + if (d >= 1000 || d == (int)d) sprintf(out, "%.0f%s", d, units[unit]); - else if (d >= 10 || d*10 == (int)(d*10)) + else if (d >= 100 || d*10 == (int)(d*10)) sprintf(out, "%.1f%s", d, units[unit]); - else + else if (d >= 10 || d*100 == (int)(d*100)) sprintf(out, "%.2f%s", d, units[unit]); + else + sprintf(out, "%.3f%s", d, units[unit]); } static void @@ -285,6 +364,7 @@ hud_pane_accumulate_vertices(struct hud_context *hud, float *line_verts = hud->whitelines.vertices + hud->whitelines.num_vertices*2; unsigned i, num = 0; char str[32]; + const unsigned last_line = pane->last_line; /* draw background */ hud_draw_background_quad(hud, @@ -292,14 +372,15 @@ hud_pane_accumulate_vertices(struct hud_context *hud, pane->x2, pane->y2); /* draw numbers on the right-hand side */ - for (i = 0; i < 6; i++) { + for (i = 0; i <= last_line; i++) { unsigned x = pane->x2 + 2; - unsigned y = pane->inner_y1 + pane->inner_height * (5 - i) / 5 - + unsigned y = pane->inner_y1 + + pane->inner_height * (last_line - i) / last_line - hud->font.glyph_height / 2; - number_to_human_readable(pane->max_value * i / 5, - pane->uses_byte_units, str); - hud_draw_string(hud, x, y, str); + number_to_human_readable(pane->max_value * i / last_line, pane->max_value, + pane->type, str); + hud_draw_string(hud, x, y, "%s", str); } /* draw info below the pane */ @@ -308,37 +389,38 @@ hud_pane_accumulate_vertices(struct hud_context *hud, unsigned x = pane->x1 + 2; unsigned y = pane->y2 + 2 + i*hud->font.glyph_height; - number_to_human_readable(gr->current_value, - pane->uses_byte_units, str); + number_to_human_readable(gr->current_value, pane->max_value, + pane->type, str); hud_draw_string(hud, x, y, " %s: %s", gr->name, str); i++; } /* draw border */ assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices); - line_verts[num++] = pane->x1; - line_verts[num++] = pane->y1; - line_verts[num++] = pane->x2; - line_verts[num++] = pane->y1; - - line_verts[num++] = pane->x2; - line_verts[num++] = pane->y1; - line_verts[num++] = pane->x2; - line_verts[num++] = pane->y2; - - line_verts[num++] = pane->x1; - line_verts[num++] = pane->y2; - line_verts[num++] = pane->x2; - line_verts[num++] = pane->y2; - - line_verts[num++] = pane->x1; - line_verts[num++] = pane->y1; - line_verts[num++] = pane->x1; - line_verts[num++] = pane->y2; + line_verts[num++] = (float) pane->x1; + line_verts[num++] = (float) pane->y1; + line_verts[num++] = (float) pane->x2; + line_verts[num++] = (float) pane->y1; + + line_verts[num++] = (float) pane->x2; + line_verts[num++] = (float) pane->y1; + line_verts[num++] = (float) pane->x2; + line_verts[num++] = (float) pane->y2; + + line_verts[num++] = (float) pane->x1; + line_verts[num++] = (float) pane->y2; + line_verts[num++] = (float) pane->x2; + line_verts[num++] = (float) pane->y2; + + line_verts[num++] = (float) pane->x1; + line_verts[num++] = (float) pane->y1; + line_verts[num++] = (float) pane->x1; + line_verts[num++] = (float) pane->y2; /* draw horizontal lines inside the graph */ - for (i = 0; i <= 5; i++) { - float y = round((pane->max_value * i / 5.0) * pane->yscale + pane->inner_y2); + for (i = 0; i <= last_line; i++) { + float y = round((pane->max_value * i / (double)last_line) * + pane->yscale + pane->inner_y2); assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices); line_verts[num++] = pane->x1; @@ -382,7 +464,7 @@ hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v, v->max_num_vertices = num_vertices; v->vbuf.stride = stride; u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices, - &v->vbuf.buffer_offset, &v->vbuf.buffer, + 16, &v->vbuf.buffer_offset, &v->vbuf.buffer, (void**)&v->vertices); } @@ -403,31 +485,50 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) struct hud_pane *pane; struct hud_graph *gr; + if (!huds_visible) + return; + hud->fb_width = tex->width0; hud->fb_height = tex->height0; - hud->constants.two_div_fb_width = 2.0 / hud->fb_width; - hud->constants.two_div_fb_height = 2.0 / hud->fb_height; - - cso_save_framebuffer(cso); - cso_save_sample_mask(cso); - cso_save_blend(cso); - cso_save_depth_stencil_alpha(cso); - cso_save_fragment_shader(cso); - cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT); - cso_save_samplers(cso, PIPE_SHADER_FRAGMENT); - cso_save_rasterizer(cso); - cso_save_viewport(cso); - cso_save_stream_outputs(cso); - cso_save_geometry_shader(cso); - cso_save_vertex_shader(cso); - cso_save_vertex_elements(cso); - cso_save_aux_vertex_buffer_slot(cso); + hud->constants.two_div_fb_width = 2.0f / hud->fb_width; + hud->constants.two_div_fb_height = 2.0f / hud->fb_height; + + cso_save_state(cso, (CSO_BIT_FRAMEBUFFER | + CSO_BIT_SAMPLE_MASK | + CSO_BIT_MIN_SAMPLES | + CSO_BIT_BLEND | + CSO_BIT_DEPTH_STENCIL_ALPHA | + CSO_BIT_FRAGMENT_SHADER | + CSO_BIT_FRAGMENT_SAMPLER_VIEWS | + CSO_BIT_FRAGMENT_SAMPLERS | + CSO_BIT_RASTERIZER | + CSO_BIT_VIEWPORT | + CSO_BIT_STREAM_OUTPUTS | + CSO_BIT_GEOMETRY_SHADER | + CSO_BIT_TESSCTRL_SHADER | + CSO_BIT_TESSEVAL_SHADER | + CSO_BIT_VERTEX_SHADER | + CSO_BIT_VERTEX_ELEMENTS | + CSO_BIT_AUX_VERTEX_BUFFER_SLOT | + CSO_BIT_PAUSE_QUERIES | + CSO_BIT_RENDER_CONDITION)); cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX); - cso_save_render_condition(cso); /* set states */ memset(&surf_templ, 0, sizeof(surf_templ)); surf_templ.format = tex->format; + + /* Without this, AA lines look thinner if they are between 2 pixels + * because the alpha is 0.5 on both pixels. (it's ugly) + * + * sRGB makes the width of all AA lines look the same. + */ + if (hud->has_srgb) { + enum pipe_format srgb_format = util_format_srgb(tex->format); + + if (srgb_format != PIPE_FORMAT_NONE) + surf_templ.format = srgb_format; + } surf = pipe->create_surface(pipe, tex, &surf_templ); memset(&fb, 0, sizeof(fb)); @@ -440,34 +541,36 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) viewport.scale[0] = 0.5f * hud->fb_width; viewport.scale[1] = 0.5f * hud->fb_height; viewport.scale[2] = 1.0f; - viewport.scale[3] = 1.0f; viewport.translate[0] = 0.5f * hud->fb_width; viewport.translate[1] = 0.5f * hud->fb_height; viewport.translate[2] = 0.0f; - viewport.translate[3] = 0.0f; cso_set_framebuffer(cso, &fb); cso_set_sample_mask(cso, ~0); - cso_set_blend(cso, &hud->alpha_blend); + cso_set_min_samples(cso, 1); cso_set_depth_stencil_alpha(cso, &hud->dsa); cso_set_rasterizer(cso, &hud->rasterizer); cso_set_viewport(cso, &viewport); - cso_set_stream_outputs(cso, 0, NULL, 0); + cso_set_stream_outputs(cso, 0, NULL, NULL); + cso_set_tessctrl_shader_handle(cso, NULL); + cso_set_tesseval_shader_handle(cso, NULL); cso_set_geometry_shader_handle(cso, NULL); cso_set_vertex_shader_handle(cso, hud->vs); cso_set_vertex_elements(cso, 2, hud->velems); - cso_set_render_condition(cso, NULL, 0); + cso_set_render_condition(cso, NULL, FALSE, 0); cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &hud->font_sampler_view); cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states); cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf); /* prepare vertex buffers */ - hud_alloc_vertices(hud, &hud->bg, 4 * 128, 2 * sizeof(float)); + hud_alloc_vertices(hud, &hud->bg, 4 * 256, 2 * sizeof(float)); hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float)); - hud_alloc_vertices(hud, &hud->text, 4 * 512, 4 * sizeof(float)); + hud_alloc_vertices(hud, &hud->text, 4 * 1024, 4 * sizeof(float)); /* prepare all graphs */ + hud_batch_query_update(hud->batch_query); + LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) { LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) { gr->query_new_value(gr); @@ -477,16 +580,17 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) } /* unmap the uploader's vertex buffer before drawing */ - u_upload_flush(hud->uploader); + u_upload_unmap(hud->uploader); /* draw accumulated vertices for background quads */ + cso_set_blend(cso, &hud->alpha_blend); cso_set_fragment_shader_handle(hud->cso, hud->fs_color); if (hud->bg.num_vertices) { hud->constants.color[0] = 0; hud->constants.color[1] = 0; hud->constants.color[2] = 0; - hud->constants.color[3] = 0.666; + hud->constants.color[3] = 0.666f; hud->constants.translate[0] = 0; hud->constants.translate[1] = 0; hud->constants.scale[0] = 1; @@ -500,6 +604,8 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) pipe_resource_reference(&hud->bg.vbuf.buffer, NULL); /* draw accumulated vertices for white lines */ + cso_set_blend(cso, &hud->no_blend); + hud->constants.color[0] = 1; hud->constants.color[1] = 1; hud->constants.color[2] = 1; @@ -519,6 +625,7 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL); /* draw accumulated vertices for text */ + cso_set_blend(cso, &hud->alpha_blend); if (hud->text.num_vertices) { cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1, &hud->text.vbuf); @@ -528,32 +635,25 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) pipe_resource_reference(&hud->text.vbuf.buffer, NULL); /* draw the rest */ + cso_set_rasterizer(cso, &hud->rasterizer_aa_lines); LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) { if (pane) hud_pane_draw_colored_objects(hud, pane); } - /* restore states */ - cso_restore_framebuffer(cso); - cso_restore_sample_mask(cso); - cso_restore_blend(cso); - cso_restore_depth_stencil_alpha(cso); - cso_restore_fragment_shader(cso); - cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT); - cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT); - cso_restore_rasterizer(cso); - cso_restore_viewport(cso); - cso_restore_stream_outputs(cso); - cso_restore_geometry_shader(cso); - cso_restore_vertex_shader(cso); - cso_restore_vertex_elements(cso); - cso_restore_aux_vertex_buffer_slot(cso); + cso_restore_state(cso); cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX); - cso_restore_render_condition(cso); pipe_surface_reference(&surf, NULL); } +static void +fixup_bytes(enum pipe_driver_query_type type, int position, uint64_t *exp10) +{ + if (type == PIPE_DRIVER_QUERY_TYPE_BYTES && position % 3 == 0) + *exp10 = (*exp10 / 1000) * 1024; +} + /** * Set the maximum value for the Y axis of the graph. * This scales the graph accordingly. @@ -561,13 +661,107 @@ hud_draw(struct hud_context *hud, struct pipe_resource *tex) void hud_pane_set_max_value(struct hud_pane *pane, uint64_t value) { - pane->max_value = value; - pane->yscale = -(int)pane->inner_height / (double)pane->max_value; + double leftmost_digit; + uint64_t exp10; + int i; + + /* The following code determines the max_value in the graph as well as + * how many describing lines are drawn. The max_value is rounded up, + * so that all drawn numbers are rounded for readability. + * We want to print multiples of a simple number instead of multiples of + * hard-to-read numbers like 1.753. + */ + + /* Find the left-most digit. */ + exp10 = 1; + for (i = 0; value > 9 * exp10; i++) { + exp10 *= 10; + fixup_bytes(pane->type, i + 1, &exp10); + } + + leftmost_digit = DIV_ROUND_UP(value, exp10); + + /* Round 9 to 10. */ + if (leftmost_digit == 9) { + leftmost_digit = 1; + exp10 *= 10; + fixup_bytes(pane->type, i + 1, &exp10); + } + + switch ((unsigned)leftmost_digit) { + case 1: + pane->last_line = 5; /* lines in +1/5 increments */ + break; + case 2: + pane->last_line = 8; /* lines in +1/4 increments. */ + break; + case 3: + case 4: + pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments */ + break; + case 5: + case 6: + case 7: + case 8: + pane->last_line = leftmost_digit; /* lines in +1 increments */ + break; + default: + assert(0); + } + + /* Truncate {3,4} to {2.5, 3.5} if possible. */ + for (i = 3; i <= 4; i++) { + if (leftmost_digit == i && value <= (i - 0.5) * exp10) { + leftmost_digit = i - 0.5; + pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments. */ + } + } + + /* Truncate 2 to a multiple of 0.2 in (1, 1.6] if possible. */ + if (leftmost_digit == 2) { + for (i = 1; i <= 3; i++) { + if (value <= (1 + i*0.2) * exp10) { + leftmost_digit = 1 + i*0.2; + pane->last_line = 5 + i; /* lines in +1/5 increments. */ + break; + } + } + } + + pane->max_value = leftmost_digit * exp10; + pane->yscale = -(int)pane->inner_height / (float)pane->max_value; +} + +static void +hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane) +{ + unsigned i; + float tmp = 0.0f; + + if (pane->dyn_ceil_last_ran != gr->index) { + LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) { + for (i = 0; i < gr->num_vertices; ++i) { + tmp = gr->vertices[i * 2 + 1] > tmp ? + gr->vertices[i * 2 + 1] : tmp; + } + } + + /* Avoid setting it lower than the initial starting height. */ + tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value; + hud_pane_set_max_value(pane, tmp); + } + + /* + * Mark this adjustment run so we could avoid repeating a full update + * again needlessly in case the pane has more than one graph. + */ + pane->dyn_ceil_last_ran = gr->index; } static struct hud_pane * hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2, - unsigned period, uint64_t max_value) + unsigned period, uint64_t max_value, uint64_t ceiling, + boolean dyn_ceiling) { struct hud_pane *pane = CALLOC_STRUCT(hud_pane); @@ -586,6 +780,10 @@ hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2, pane->inner_height = pane->inner_y2 - pane->inner_y1; pane->period = period; pane->max_num_vertices = (x2 - x1 + 2) / 2; + pane->ceiling = ceiling; + pane->dyn_ceiling = dyn_ceiling; + pane->dyn_ceil_last_ran = 0; + pane->initial_max_value = max_value; hud_pane_set_max_value(pane, max_value); LIST_INITHEAD(&pane->graph_list); return pane; @@ -616,7 +814,7 @@ hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr) name++; } - assert(pane->num_graphs < Elements(colors)); + assert(pane->num_graphs < ARRAY_SIZE(colors)); gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2); gr->color[0] = colors[pane->num_graphs][0]; gr->color[1] = colors[pane->num_graphs][1]; @@ -629,20 +827,25 @@ hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr) void hud_graph_add_value(struct hud_graph *gr, uint64_t value) { + gr->current_value = value; + value = value > gr->pane->ceiling ? gr->pane->ceiling : value; + if (gr->index == gr->pane->max_num_vertices) { gr->vertices[0] = 0; gr->vertices[1] = gr->vertices[(gr->index-1)*2+1]; gr->index = 1; } - gr->vertices[(gr->index)*2+0] = gr->index*2; - gr->vertices[(gr->index)*2+1] = value; + gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2); + gr->vertices[(gr->index)*2+1] = (float) value; gr->index++; if (gr->num_vertices < gr->pane->max_num_vertices) { gr->num_vertices++; } - gr->current_value = value; + if (gr->pane->dyn_ceiling == true) { + hud_pane_update_dyn_ceiling(gr, gr->pane); + } if (value > gr->pane->max_value) { hud_pane_set_max_value(gr->pane, value); } @@ -679,6 +882,69 @@ parse_string(const char *s, char *out) return i; } +static char * +read_pane_settings(char *str, unsigned * const x, unsigned * const y, + unsigned * const width, unsigned * const height, + uint64_t * const ceiling, boolean * const dyn_ceiling) +{ + char *ret = str; + unsigned tmp; + + while (*str == '.') { + ++str; + switch (*str) { + case 'x': + ++str; + *x = strtoul(str, &ret, 10); + str = ret; + break; + + case 'y': + ++str; + *y = strtoul(str, &ret, 10); + str = ret; + break; + + case 'w': + ++str; + tmp = strtoul(str, &ret, 10); + *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */ + str = ret; + break; + + /* + * Prevent setting height to less than 50. If the height is set to less, + * the text of the Y axis labels on the graph will start overlapping. + */ + case 'h': + ++str; + tmp = strtoul(str, &ret, 10); + *height = tmp > 50 ? tmp : 50; + str = ret; + break; + + case 'c': + ++str; + tmp = strtoul(str, &ret, 10); + *ceiling = tmp > 10 ? tmp : 10; + str = ret; + break; + + case 'd': + ++str; + ret = str; + *dyn_ceiling = true; + break; + + default: + fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str); + } + + } + + return ret; +} + static boolean has_occlusion_query(struct pipe_screen *screen) { @@ -701,11 +967,15 @@ static void hud_parse_env_var(struct hud_context *hud, const char *env) { unsigned num, i; - char name[256], s[256]; + char name_a[256], s[256]; + char *name; struct hud_pane *pane = NULL; unsigned x = 10, y = 10; unsigned width = 251, height = 100; unsigned period = 500 * 1000; /* default period (1/2 second) */ + uint64_t ceiling = UINT64_MAX; + unsigned column_width = 251; + boolean dyn_ceiling = false; const char *period_env; /* @@ -715,22 +985,37 @@ hud_parse_env_var(struct hud_context *hud, const char *env) */ period_env = getenv("GALLIUM_HUD_PERIOD"); if (period_env) { - float p = atof(period_env); - if (p >= 0.0) { + float p = (float) atof(period_env); + if (p >= 0.0f) { period = (unsigned) (p * 1000 * 1000); } } - while ((num = parse_string(env, name)) != 0) { + while ((num = parse_string(env, name_a)) != 0) { env += num; + /* check for explicit location, size and etc. settings */ + name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling, + &dyn_ceiling); + + /* + * Keep track of overall column width to avoid pane overlapping in case + * later we create a new column while the bottom pane in the current + * column is less wide than the rest of the panes in it. + */ + column_width = width > column_width ? width : column_width; + if (!pane) { - pane = hud_pane_create(x, y, x + width, y + height, period, 10); + pane = hud_pane_create(x, y, x + width, y + height, period, 10, + ceiling, dyn_ceiling); if (!pane) return; } /* Add a graph. */ +#if HAVE_GALLIUM_EXTRA_HUD || HAVE_LIBSENSORS + char arg_name[64]; +#endif /* IF YOU CHANGE THIS, UPDATE print_help! */ if (strcmp(name, "fps") == 0) { hud_fps_graph_install(pane); @@ -741,15 +1026,65 @@ hud_parse_env_var(struct hud_context *hud, const char *env) else if (sscanf(name, "cpu%u%s", &i, s) == 1) { hud_cpu_graph_install(pane, i); } +#if HAVE_GALLIUM_EXTRA_HUD + else if (sscanf(name, "nic-rx-%s", arg_name) == 1) { + hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_RX); + } + else if (sscanf(name, "nic-tx-%s", arg_name) == 1) { + hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_TX); + } + else if (sscanf(name, "nic-rssi-%s", arg_name) == 1) { + hud_nic_graph_install(pane, arg_name, NIC_RSSI_DBM); + pane->type = PIPE_DRIVER_QUERY_TYPE_DBM; + } + else if (sscanf(name, "diskstat-rd-%s", arg_name) == 1) { + hud_diskstat_graph_install(pane, arg_name, DISKSTAT_RD); + pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES; + } + else if (sscanf(name, "diskstat-wr-%s", arg_name) == 1) { + hud_diskstat_graph_install(pane, arg_name, DISKSTAT_WR); + pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES; + } +#endif +#if HAVE_LIBSENSORS + else if (sscanf(name, "sensors_temp_cu-%s", arg_name) == 1) { + hud_sensors_temp_graph_install(pane, arg_name, + SENSORS_TEMP_CURRENT); + pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE; + } + else if (sscanf(name, "sensors_temp_cr-%s", arg_name) == 1) { + hud_sensors_temp_graph_install(pane, arg_name, + SENSORS_TEMP_CRITICAL); + pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE; + } + else if (sscanf(name, "sensors_volt_cu-%s", arg_name) == 1) { + hud_sensors_temp_graph_install(pane, arg_name, + SENSORS_VOLTAGE_CURRENT); + pane->type = PIPE_DRIVER_QUERY_TYPE_VOLTS; + } + else if (sscanf(name, "sensors_curr_cu-%s", arg_name) == 1) { + hud_sensors_temp_graph_install(pane, arg_name, + SENSORS_CURRENT_CURRENT); + pane->type = PIPE_DRIVER_QUERY_TYPE_AMPS; + } +#endif else if (strcmp(name, "samples-passed") == 0 && has_occlusion_query(hud->pipe->screen)) { - hud_pipe_query_install(pane, hud->pipe, "samples-passed", - PIPE_QUERY_OCCLUSION_COUNTER, 0, 0, FALSE); + hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, + "samples-passed", + PIPE_QUERY_OCCLUSION_COUNTER, 0, 0, + PIPE_DRIVER_QUERY_TYPE_UINT64, + PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE, + 0); } else if (strcmp(name, "primitives-generated") == 0 && has_streamout(hud->pipe->screen)) { - hud_pipe_query_install(pane, hud->pipe, "primitives-generated", - PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0, FALSE); + hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, + "primitives-generated", + PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0, + PIPE_DRIVER_QUERY_TYPE_UINT64, + PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE, + 0); } else { boolean processed = FALSE; @@ -770,20 +1105,23 @@ hud_parse_env_var(struct hud_context *hud, const char *env) "ds-invocations", "cs-invocations" }; - for (i = 0; i < Elements(pipeline_statistics_names); ++i) + for (i = 0; i < ARRAY_SIZE(pipeline_statistics_names); ++i) if (strcmp(name, pipeline_statistics_names[i]) == 0) break; - if (i < Elements(pipeline_statistics_names)) { - hud_pipe_query_install(pane, hud->pipe, name, + if (i < ARRAY_SIZE(pipeline_statistics_names)) { + hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name, PIPE_QUERY_PIPELINE_STATISTICS, i, - 0, FALSE); + 0, PIPE_DRIVER_QUERY_TYPE_UINT64, + PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE, + 0); processed = TRUE; } } /* driver queries */ if (!processed) { - if (!hud_driver_query_install(pane, hud->pipe, name)){ + if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe, + name)) { fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name); } } @@ -803,6 +1141,7 @@ hud_parse_env_var(struct hud_context *hud, const char *env) if (num && sscanf(s, "%u", &i) == 1) { hud_pane_set_max_value(pane, i); + pane->initial_max_value = i; } else { fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) " @@ -821,7 +1160,11 @@ hud_parse_env_var(struct hud_context *hud, const char *env) case ',': env++; + if (!pane) + break; + y += height + hud->font.glyph_height * (pane->num_graphs + 2); + height = 100; if (pane && pane->num_graphs) { LIST_ADDTAIL(&pane->head, &hud->pane_list); @@ -832,17 +1175,27 @@ hud_parse_env_var(struct hud_context *hud, const char *env) case ';': env++; y = 10; - x += width + hud->font.glyph_width * 7; + x += column_width + hud->font.glyph_width * 9; + height = 100; if (pane && pane->num_graphs) { LIST_ADDTAIL(&pane->head, &hud->pane_list); pane = NULL; } + + /* Starting a new column; reset column width. */ + column_width = 251; break; default: fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env); } + + /* Reset to defaults for the next pane in case these were modified. */ + width = 251; + ceiling = UINT64_MAX; + dyn_ceiling = false; + } if (pane) { @@ -874,6 +1227,30 @@ print_help(struct pipe_screen *screen) puts(""); puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\""); puts(""); + puts(" Additionally, by prepending '.[identifier][value]' modifiers to"); + puts(" a name, it is possible to explicitly set the location and size"); + puts(" of a pane, along with limiting overall maximum value of the"); + puts(" Y axis and activating dynamic readjustment of the Y axis."); + puts(" Several modifiers may be applied to the same pane simultaneously."); + puts(""); + puts(" 'x[value]' sets the location of the pane on the x axis relative"); + puts(" to the upper-left corner of the viewport, in pixels."); + puts(" 'y[value]' sets the location of the pane on the y axis relative"); + puts(" to the upper-left corner of the viewport, in pixels."); + puts(" 'w[value]' sets width of the graph pixels."); + puts(" 'h[value]' sets height of the graph in pixels."); + puts(" 'c[value]' sets the ceiling of the value of the Y axis."); + puts(" If the graph needs to draw values higher than"); + puts(" the ceiling allows, the value is clamped."); + puts(" 'd' activates dynamic Y axis readjustment to set the value of"); + puts(" the Y axis to match the highest value still visible in the graph."); + puts(""); + puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:"); + puts(" the Y axis does not go above the restriction imposed by 'c' while"); + puts(" still adjusting the value of the Y axis down when appropriate."); + puts(""); + puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\""); + puts(""); puts(" Available names:"); puts(" fps"); puts(" cpu"); @@ -900,26 +1277,50 @@ print_help(struct pipe_screen *screen) puts(" cs-invocations"); } +#if HAVE_GALLIUM_EXTRA_HUD + hud_get_num_disks(1); + hud_get_num_nics(1); +#endif +#if HAVE_LIBSENSORS + hud_get_num_sensors(1); +#endif + if (screen->get_driver_query_info){ + boolean skipping = false; struct pipe_driver_query_info info; num_queries = screen->get_driver_query_info(screen, 0, NULL); for (i = 0; i < num_queries; i++){ screen->get_driver_query_info(screen, i, &info); - printf(" %s\n", info.name); + if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) { + if (!skipping) + puts(" ..."); + skipping = true; + } else { + printf(" %s\n", info.name); + skipping = false; + } } } puts(""); + fflush(stdout); } struct hud_context * hud_create(struct pipe_context *pipe, struct cso_context *cso) { + struct pipe_screen *screen = pipe->screen; struct hud_context *hud; struct pipe_sampler_view view_templ; unsigned i; const char *env = debug_get_option("GALLIUM_HUD", NULL); +#ifdef PIPE_OS_UNIX + unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0); + static boolean sig_handled = FALSE; + struct sigaction action = {}; +#endif + huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE); if (!env || !*env) return NULL; @@ -935,8 +1336,8 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) hud->pipe = pipe; hud->cso = cso; - hud->uploader = u_upload_create(pipe, 256 * 1024, 16, - PIPE_BIND_VERTEX_BUFFER); + hud->uploader = u_upload_create(pipe, 256 * 1024, + PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_STREAM); /* font */ if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) { @@ -945,7 +1346,14 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) return NULL; } + hud->has_srgb = screen->is_format_supported(screen, + PIPE_FORMAT_B8G8R8A8_SRGB, + PIPE_TEXTURE_2D, 0, + PIPE_BIND_RENDER_TARGET) != 0; + /* blend state */ + hud->no_blend.rt[0].colormask = PIPE_MASK_RGBA; + hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA; hud->alpha_blend.rt[0].blend_enable = 1; hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD; @@ -959,7 +1367,8 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) hud->fs_color = util_make_fragment_passthrough_shader(pipe, TGSI_SEMANTIC_COLOR, - TGSI_INTERPOLATE_CONSTANT); + TGSI_INTERPOLATE_CONSTANT, + TRUE); { /* Read a texture and do .xxxx swizzling. */ @@ -967,6 +1376,7 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) "FRAG\n" "DCL IN[0], GENERIC[0], LINEAR\n" "DCL SAMP[0]\n" + "DCL SVIEW[0], RECT, FLOAT\n" "DCL OUT[0], COLOR[0]\n" "DCL TEMP[0]\n" @@ -976,25 +1386,29 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) }; struct tgsi_token tokens[1000]; - struct pipe_shader_state state = {tokens}; + struct pipe_shader_state state; - if (!tgsi_text_translate(fragment_shader_text, tokens, Elements(tokens))) { + if (!tgsi_text_translate(fragment_shader_text, tokens, ARRAY_SIZE(tokens))) { assert(0); pipe_resource_reference(&hud->font.texture, NULL); u_upload_destroy(hud->uploader); FREE(hud); return NULL; } - + pipe_shader_state_from_tgsi(&state, tokens); hud->fs_text = pipe->create_fs_state(pipe, &state); } /* rasterizer */ - hud->rasterizer.gl_rasterization_rules = 1; + hud->rasterizer.half_pixel_center = 1; + hud->rasterizer.bottom_edge_rule = 1; hud->rasterizer.depth_clip = 1; hud->rasterizer.line_width = 1; hud->rasterizer.line_last_pixel = 1; + hud->rasterizer_aa_lines = hud->rasterizer; + hud->rasterizer_aa_lines.line_smooth = 1; + /* vertex shader */ { static const char *vertex_shader_text = { @@ -1022,16 +1436,15 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) }; struct tgsi_token tokens[1000]; - struct pipe_shader_state state = {tokens}; - - if (!tgsi_text_translate(vertex_shader_text, tokens, Elements(tokens))) { + struct pipe_shader_state state; + if (!tgsi_text_translate(vertex_shader_text, tokens, ARRAY_SIZE(tokens))) { assert(0); pipe_resource_reference(&hud->font.texture, NULL); u_upload_destroy(hud->uploader); FREE(hud); return NULL; } - + pipe_shader_state_from_tgsi(&state, tokens); hud->vs = pipe->create_vs_state(pipe, &state); } @@ -1043,12 +1456,8 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) } /* sampler view */ - memset(&view_templ, 0, sizeof(view_templ)); - view_templ.format = hud->font.texture->format; - view_templ.swizzle_r = PIPE_SWIZZLE_RED; - view_templ.swizzle_g = PIPE_SWIZZLE_GREEN; - view_templ.swizzle_b = PIPE_SWIZZLE_BLUE; - view_templ.swizzle_a = PIPE_SWIZZLE_ALPHA; + u_sampler_view_default_template( + &view_templ, hud->font.texture, hud->font.texture->format); hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture, &view_templ); @@ -1064,6 +1473,22 @@ hud_create(struct pipe_context *pipe, struct cso_context *cso) LIST_INITHEAD(&hud->pane_list); + /* setup sig handler once for all hud contexts */ +#ifdef PIPE_OS_UNIX + if (!sig_handled && signo != 0) { + action.sa_sigaction = &signal_visible_handler; + action.sa_flags = SA_SIGINFO; + + if (signo >= NSIG) + fprintf(stderr, "gallium_hud: invalid signal %u\n", signo); + else if (sigaction(signo, &action, NULL) < 0) + fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo); + fflush(stderr); + + sig_handled = TRUE; + } +#endif + hud_parse_env_var(hud, env); return hud; } @@ -1084,6 +1509,7 @@ hud_destroy(struct hud_context *hud) FREE(pane); } + hud_batch_query_cleanup(&hud->batch_query); pipe->delete_fs_state(pipe, hud->fs_color); pipe->delete_fs_state(pipe, hud->fs_text); pipe->delete_vs_state(pipe, hud->vs);