unsigned int uterm_screen_height(struct uterm_screen *screen)
{
if (!screen)
return 0;
return uterm_mode_get_height(uterm_display_get_current(screen->disp));
}
static int bbulk_set(struct kmscon_text *txt)
{
struct bbulk *bb = txt->data;
unsigned int sw, sh, i, j;
struct uterm_video_blend_req *req;
struct uterm_mode *mode;
memset(bb, 0, sizeof(*bb));
mode = uterm_display_get_current(txt->disp);
if (!mode)
return -EINVAL;
sw = uterm_mode_get_width(mode);
sh = uterm_mode_get_height(mode);
txt->cols = sw / FONT_WIDTH(txt);
txt->rows = sh / FONT_HEIGHT(txt);
bb->reqs = malloc(sizeof(*bb->reqs) * txt->cols * txt->rows);
if (!bb->reqs)
return -ENOMEM;
memset(bb->reqs, 0, sizeof(*bb->reqs) * txt->cols * txt->rows);
for (i = 0; i < txt->rows; ++i) {
for (j = 0; j < txt->cols; ++j) {
req = &bb->reqs[i * txt->cols + j];
req->x = j * FONT_WIDTH(txt);
req->y = i * FONT_HEIGHT(txt);
}
}
return 0;
}
static int list_outputs(struct uterm_video *video)
{
struct uterm_display *iter;
struct uterm_mode *cur, *mode;
int i;
log_notice("List of Outputs:");
i = 0;
iter = uterm_video_get_displays(video);
for ( ; iter; iter = uterm_display_next(iter)) {
cur = uterm_display_get_current(iter);
log_notice("Output %d:", i++);
log_notice(" active: %d", uterm_display_get_state(iter));
log_notice(" has current: %s", cur ? "yes" : "no");
mode = uterm_display_get_modes(iter);
for ( ; mode; mode = uterm_mode_next(mode)) {
log_notice(" Mode '%s':", uterm_mode_get_name(mode));
log_notice(" x: %u", uterm_mode_get_width(mode));
log_notice(" y: %u", uterm_mode_get_height(mode));
}
}
log_notice("End of Output list");
return 0;
}
static int blit_outputs(struct uterm_video *video)
{
struct uterm_display *iter;
int j, ret;
struct uterm_mode *mode;
j = 0;
iter = uterm_video_get_displays(video);
for ( ; iter; iter = uterm_display_next(iter)) {
log_notice("Activating display %d %p...", j, iter);
ret = uterm_display_activate(iter, NULL);
if (ret)
log_err("Cannot activate display %d: %d", j, ret);
else
log_notice("Successfully activated display %d", j);
ret = uterm_display_set_dpms(iter, UTERM_DPMS_ON);
if (ret)
log_err("Cannot set DPMS to ON: %d", ret);
++j;
}
iter = uterm_video_get_displays(video);
for ( ; iter; iter = uterm_display_next(iter)) {
if (uterm_display_get_state(iter) != UTERM_DISPLAY_ACTIVE)
continue;
mode = uterm_display_get_current(iter);
ret = uterm_display_fill(iter, 0xff, 0xff, 0xff, 0, 0,
uterm_mode_get_width(mode),
uterm_mode_get_height(mode));
if (ret) {
log_err("cannot fill framebuffer");
continue;
}
ret = uterm_display_swap(iter, true);
if (ret) {
log_err("Cannot swap screen: %d", ret);
continue;
}
log_notice("Successfully set screen on display %p", iter);
}
log_notice("Waiting 5 seconds...");
ev_eloop_run(eloop, 5000);
log_notice("Exiting...");
return 0;
}
static int gltex_set(struct kmscon_text *txt)
{
struct gltex *gt = txt->data;
int ret;
static char *attr[] = { "position", "texture_position",
"fgcolor", "bgcolor" };
GLint s;
const char *ext;
struct uterm_mode *mode;
bool opengl;
memset(gt, 0, sizeof(*gt));
shl_dlist_init(>->atlases);
ret = shl_hashtable_new(>->glyphs, shl_direct_hash,
shl_direct_equal, NULL,
free_glyph);
if (ret)
return ret;
ret = shl_hashtable_new(>->bold_glyphs, shl_direct_hash,
shl_direct_equal, NULL,
free_glyph);
if (ret)
goto err_htable;
ret = uterm_display_use(txt->disp, &opengl);
if (ret < 0 || !opengl) {
if (ret == -EOPNOTSUPP)
log_error("display doesn't support hardware-acceleration");
goto err_bold_htable;
}
gl_clear_error();
ret = gl_shader_new(>->shader, gl_static_gltex_vert,
gl_static_gltex_frag, attr, 4, log_llog, NULL);
if (ret)
goto err_bold_htable;
gt->uni_proj = gl_shader_get_uniform(gt->shader, "projection");
gt->uni_atlas = gl_shader_get_uniform(gt->shader, "atlas");
gt->uni_advance_htex = gl_shader_get_uniform(gt->shader,
"advance_htex");
gt->uni_advance_vtex = gl_shader_get_uniform(gt->shader,
"advance_vtex");
if (gl_has_error(gt->shader)) {
log_warning("cannot create shader");
goto err_shader;
}
mode = uterm_display_get_current(txt->disp);
gt->sw = uterm_mode_get_width(mode);
gt->sh = uterm_mode_get_height(mode);
txt->cols = gt->sw / FONT_WIDTH(txt);
txt->rows = gt->sh / FONT_HEIGHT(txt);
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &s);
if (s <= 0)
s = 64;
else if (s > 2048)
s = 2048;
gt->max_tex_size = s;
gl_clear_error();
ext = (const char*)glGetString(GL_EXTENSIONS);
if (ext && strstr((const char*)ext, "GL_EXT_unpack_subimage")) {
gt->supports_rowlen = true;
} else {
log_warning("your GL implementation does not support GL_EXT_unpack_subimage, glyph-rendering may be slower than usual");
}
return 0;
err_shader:
gl_shader_unref(gt->shader);
err_bold_htable:
shl_hashtable_free(gt->bold_glyphs);
err_htable:
shl_hashtable_free(gt->glyphs);
return ret;
}