* Set GALLIUM_HUD=help for more info.
*/
+#include <inttypes.h>
+#include <signal.h>
#include <stdio.h>
#include "hud/hud_context.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 "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];
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,
}
static void
-number_to_human_readable(uint64_t num, boolean is_in_bytes, char *out)
+number_to_human_readable(uint64_t num, 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"};
+ static const char *watt_units[] = {" mW", " W"};
+
+ 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;
+ case PIPE_DRIVER_QUERY_TYPE_WATTS:
+ max_unit = ARRAY_SIZE(watt_units)-1;
+ units = watt_units;
+ break;
+ default:
+ 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
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,
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->type, str);
+ hud_draw_string(hud, x, y, "%s", str);
}
/* draw info below the pane */
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->type, str);
hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
i++;
}
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;
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);
}
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.0f / hud->fb_width;
hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
- cso_save_framebuffer(cso);
- cso_save_sample_mask(cso);
- cso_save_min_samples(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);
+ 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));
cso_set_framebuffer(cso, &fb);
cso_set_sample_mask(cso, ~0);
cso_set_min_samples(cso, 1);
- cso_set_blend(cso, &hud->alpha_blend);
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, 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_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);
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) {
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;
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);
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_min_samples(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.
void
hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
{
- pane->max_value = 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;
}
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];
gr->current_value = value;
value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
+ if (gr->fd)
+ fprintf(gr->fd, "%" PRIu64 "\n", value);
+
if (gr->index == gr->pane->max_num_vertices) {
gr->vertices[0] = 0;
gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
FREE(graph->vertices);
if (graph->free_query_data)
graph->free_query_data(graph->query_data);
+ if (graph->fd)
+ fclose(graph->fd);
FREE(graph);
}
+void
+hud_graph_set_dump_file(struct hud_graph *gr)
+{
+ const char *hud_dump_dir = getenv("GALLIUM_HUD_DUMP_DIR");
+ char *dump_file;
+
+ if (hud_dump_dir && access(hud_dump_dir, W_OK) == 0) {
+ dump_file = malloc(strlen(hud_dump_dir) + sizeof(gr->name));
+ if (dump_file) {
+ strcpy(dump_file, hud_dump_dir);
+ strcat(dump_file, gr->name);
+ gr->fd = fopen(dump_file, "w+");
+ free(dump_file);
+ }
+ }
+}
+
/**
* Read a string from the environment variable.
* The separators "+", ",", ":", and ";" terminate the string.
*out = 0;
- if (*s && !i)
+ if (*s && !i) {
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
"parsing a string\n", *s, *s);
+ fflush(stderr);
+ }
+
return i;
}
default:
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
+ fflush(stderr);
}
}
}
/* 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);
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;
+ }
+ else if (sscanf(name, "cpufreq-min-cpu%u", &i) == 1) {
+ hud_cpufreq_graph_install(pane, i, CPUFREQ_MINIMUM);
+ pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
+ }
+ else if (sscanf(name, "cpufreq-cur-cpu%u", &i) == 1) {
+ hud_cpufreq_graph_install(pane, i, CPUFREQ_CURRENT);
+ pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
+ }
+ else if (sscanf(name, "cpufreq-max-cpu%u", &i) == 1) {
+ hud_cpufreq_graph_install(pane, i, CPUFREQ_MAXIMUM);
+ pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
+ }
+#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;
+ }
+ else if (sscanf(name, "sensors_pow_cu-%s", arg_name) == 1) {
+ hud_sensors_temp_graph_install(pane, arg_name,
+ SENSORS_POWER_CURRENT);
+ pane->type = PIPE_DRIVER_QUERY_TYPE_WATTS;
+ }
+#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;
"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);
+ fflush(stderr);
}
}
}
if (!pane) {
fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
"expected a name\n");
+ fflush(stderr);
break;
}
else {
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
"after ':'\n", *env, *env);
+ fflush(stderr);
}
}
case ',':
env++;
+ if (!pane)
+ break;
+
y += height + hud->font.glyph_height * (pane->num_graphs + 2);
height = 100;
case ';':
env++;
y = 10;
- x += column_width + hud->font.glyph_width * 7;
+ x += column_width + hud->font.glyph_width * 9;
height = 100;
if (pane && pane->num_graphs) {
default:
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
+ fflush(stderr);
}
/* Reset to defaults for the next pane in case these were modified. */
puts(" cs-invocations");
}
+#if HAVE_GALLIUM_EXTRA_HUD
+ hud_get_num_disks(1);
+ hud_get_num_nics(1);
+ hud_get_num_cpufreq(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;
+ }
}
}
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;
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)) {
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;
"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"
};
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);
}
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 = {
};
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);
}
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;
}
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);