From 02fd08a2e640ceb9dfa7d0fd2efde6a0ff3047ca Mon Sep 17 00:00:00 2001 From: Jeffy Chen Date: Fri, 3 Jul 2020 12:37:37 +0800 Subject: [PATCH 16/79] backend-drm: Support controlling output dynamically Use config file to set output's rotate/down-scale/size/pos/mode/off/ freeze/display-rectangle and prefer/primary output. Default config file is "/tmp/.weston_drm.conf", can override with "WESTON_DRM_CONFIG" environment. Supported configs format is "output::", for example: echo "output:DSI-1:off" >> /tmp/.weston_drm.conf echo "output:eDP-1:freeze" >> /tmp/.weston_drm.conf echo "output:all:rotate90" >> /tmp/.weston_drm.conf echo "output:all:rect=<100,20,1636,2068>" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:mode=800x600" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:pos=100,200" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:size=1920x1080" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:prefer" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:primary" >> /tmp/.weston_drm.conf echo "output:HDMI-A-1:down-scale=0.5" >> /tmp/.weston_drm.conf Signed-off-by: Jeffy Chen --- compositor/main.c | 14 ++ desktop-shell/shell.c | 58 +++++- include/libweston/libweston.h | 7 + libweston/backend-drm/drm-internal.h | 16 ++ libweston/backend-drm/drm.c | 264 ++++++++++++++++++++++++++- libweston/backend-drm/modes.c | 20 +- libweston/compositor.c | 50 +++-- libweston/pixman-renderer.c | 3 + libweston/renderer-gl/gl-renderer.c | 4 + 9 files changed, 397 insertions(+), 39 deletions(-) diff --git a/compositor/main.c b/compositor/main.c index 47bf540..a4f679a 100644 --- a/compositor/main.c +++ b/compositor/main.c @@ -1832,6 +1832,20 @@ drm_backend_output_configure(struct weston_output *output, } free(s); + weston_config_section_get_string(section, "pos", &s, NULL); + if (s) { + if (sscanf(s, "%d,%d", &output->x, &output->y) == 2) + output->fixed_position = true; + free(s); + } + + weston_config_section_get_string(section, "size", &s, NULL); + if (s) { + if (sscanf(s, "%dx%d", &output->width, &output->height) == 2) + output->fixed_size = true; + free(s); + } + if (api->set_mode(output, mode, modeline) < 0) { weston_log("Cannot configure an output using weston_drm_output_api.\n"); free(modeline); diff --git a/desktop-shell/shell.c b/desktop-shell/shell.c index 18bec12..8b4ed45 100644 --- a/desktop-shell/shell.c +++ b/desktop-shell/shell.c @@ -4254,7 +4254,7 @@ weston_view_set_initial_position(struct weston_view *view, int ix = 0, iy = 0; int32_t range_x, range_y; int32_t x, y; - struct weston_output *output, *target_output = NULL; + struct weston_output *output, *target_output = NULL, *prefer_output = NULL; struct weston_seat *seat; pixman_rectangle32_t area; @@ -4279,16 +4279,20 @@ weston_view_set_initial_position(struct weston_view *view, } } - wl_list_for_each(output, &compositor->output_list, link) { + wl_list_for_each_reverse(output, &compositor->output_list, link) { if (output->unavailable) continue; - if (pixman_region32_contains_point(&output->region, ix, iy, NULL)) { + if (output == compositor->prefer_output) + prefer_output = output; + + if (pixman_region32_contains_point(&output->region, ix, iy, NULL)) target_output = output; - break; - } } + if (prefer_output) + target_output = prefer_output; + if (!target_output) { weston_view_set_position(view, 10 + random() % 400, 10 + random() % 400); @@ -4890,6 +4894,41 @@ shell_resize_surface_to_output(struct desktop_shell *shell, output->height); } +static void +handle_output_resize_layer(struct desktop_shell *shell, + struct weston_layer *layer, void *data) +{ + struct weston_output *output = data; + struct weston_view *view; + + wl_list_for_each(view, &layer->view_list.link, layer_link.link) { + struct weston_desktop_surface *desktop_surface; + struct shell_surface *shsurf; + bool dirty = false; + + if (view->output != output) + continue; + + shsurf = get_shell_surface(view->surface); + if (!shsurf) + continue; + + desktop_surface = shsurf->desktop_surface; + if (weston_desktop_surface_get_fullscreen(desktop_surface)) { + set_fullscreen(shsurf, true, output); + dirty = true; + } + if (weston_desktop_surface_get_maximized(desktop_surface)) { + set_maximized(shsurf, true); + dirty = true; + } + + if (dirty) { + weston_view_geometry_dirty(view); + weston_surface_damage(view->surface); + } + } +} static void handle_output_resized(struct wl_listener *listener, void *data) @@ -4899,8 +4938,13 @@ handle_output_resized(struct wl_listener *listener, void *data) struct weston_output *output = (struct weston_output *)data; struct shell_output *sh_output = find_shell_output_from_weston_output(shell, output); + if (shell->lock_surface) + shell->lock_surface->committed(shell->lock_surface, 0, 0); + shell_resize_surface_to_output(shell, sh_output->background_surface, output); shell_resize_surface_to_output(shell, sh_output->panel_surface, output); + + shell_for_each_layer(shell, handle_output_resize_layer, data); } static void @@ -4949,7 +4993,9 @@ handle_output_move_layer(struct desktop_shell *shell, x = view->geometry.x + output->move_x; y = view->geometry.y + output->move_y; - weston_view_set_position(view, x, y); + + if (pixman_region32_contains_point(&output->region, x, y, NULL)) + weston_view_set_position(view, x, y); } } diff --git a/include/libweston/libweston.h b/include/libweston/libweston.h index 8868622..24e44a2 100644 --- a/include/libweston/libweston.h +++ b/include/libweston/libweston.h @@ -413,6 +413,12 @@ struct weston_output { struct weston_head *head); bool unavailable; + bool freezing; + + bool fixed_position; + bool fixed_size; + + double down_scale; }; #define weston_output_valid(o) \ ((o) && !(o)->destroying && !(o)->unavailable) @@ -1198,6 +1204,7 @@ struct weston_compositor { struct content_protection *content_protection; enum weston_output_flow output_flow; + struct weston_output *prefer_output; }; struct weston_buffer { diff --git a/libweston/backend-drm/drm-internal.h b/libweston/backend-drm/drm-internal.h index 1625be2..9d24017 100644 --- a/libweston/backend-drm/drm-internal.h +++ b/libweston/backend-drm/drm-internal.h @@ -115,6 +115,9 @@ #define DRM_RESIZE_FREEZE_MS 600 +#define WESTON_DRM_CONFIG_FILE "/tmp/.weston_drm.conf" +#define DRM_CONFIG_UPDATE_MS 100 + /** * Represents the values of an enum-type KMS property */ @@ -348,6 +351,9 @@ struct drm_backend { int virtual_height; bool mirror_mode; + + struct wl_event_source *config_timer; + struct stat config_stat; }; struct drm_mode { @@ -626,6 +632,9 @@ struct drm_output { bool is_mirror; pixman_box32_t plane_bounds; + + uint32_t original_transform; + int64_t last_resize_ms; }; static inline struct drm_head * @@ -708,6 +717,13 @@ drm_mode_list_destroy(struct drm_backend *backend, struct wl_list *mode_list); void drm_output_print_modes(struct drm_output *output); +struct drm_mode * +drm_output_choose_initial_mode(struct drm_backend *backend, + struct drm_output *output, + enum weston_drm_backend_output_mode mode, + const char *modeline, + const drmModeModeInfo *current_mode); + int drm_output_set_mode(struct weston_output *base, enum weston_drm_backend_output_mode mode, diff --git a/libweston/backend-drm/drm.c b/libweston/backend-drm/drm.c index 696df68..1d6f7db 100644 --- a/libweston/backend-drm/drm.c +++ b/libweston/backend-drm/drm.c @@ -40,6 +40,7 @@ #include #include #include +#include #include #include @@ -74,6 +75,8 @@ static const char default_seat[] = "seat0"; +static int config_timer_handler(void *data); + static inline bool drm_head_is_external(struct drm_head *head) { @@ -205,7 +208,7 @@ close_src: static void drm_backend_update_outputs(struct drm_backend *b) { - struct weston_output *primary; + struct weston_output *base, *primary; if (!b->primary_head) return; @@ -493,6 +496,12 @@ drm_output_update_complete(struct drm_output *output, uint32_t flags, return; } + if (!sec && !usec) { + weston_output_finish_frame(&output->base, NULL, + WP_PRESENTATION_FEEDBACK_INVALID); + return; + } + ts.tv_sec = sec; ts.tv_nsec = usec * 1000; @@ -671,8 +680,8 @@ out: return; } - sw = fb->width; - sh = fb->height; + sw = fb->width * output->base.down_scale; + sh = fb->height * output->base.down_scale; dx = output->plane_bounds.x1; dy = output->plane_bounds.y1; @@ -823,7 +832,8 @@ drm_output_repaint(struct weston_output *output_base, weston_compositor_read_presentation_clock(b->compositor, &now); now_ms = timespec_to_msec(&now); - if (now_ms < b->last_resize_ms + b->resize_freeze_ms) { + if (now_ms < b->last_resize_ms + b->resize_freeze_ms || + now_ms < output->last_resize_ms + b->resize_freeze_ms) { /* Resize fullscreen/maxmium views(not always success) */ if (now_ms < b->last_resize_ms + DRM_RESIZE_FREEZE_MS) wl_signal_emit(&b->compositor->output_resized_signal, @@ -832,7 +842,7 @@ drm_output_repaint(struct weston_output *output_base, weston_output_damage(output_base); weston_output_finish_frame(output_base, NULL, WP_PRESENTATION_FEEDBACK_INVALID); - return 0; + goto not_repainted; } /* If planes have been disabled in the core, we might not have @@ -860,7 +870,8 @@ drm_output_repaint(struct weston_output *output_base, err: drm_output_state_free(state); - return 0; +not_repainted: + return 1; } /* Determine the type of vblank synchronization to use for the output. @@ -2213,6 +2224,8 @@ drm_output_enable(struct weston_output *base) output->base.switch_mode = drm_output_switch_mode; output->base.set_gamma = drm_output_set_gamma; + output->original_transform = output->base.transform; + output->state_invalid = true; weston_log("Output %s (crtc %d) video modes:\n", @@ -3061,6 +3074,7 @@ drm_destroy(struct weston_compositor *ec) udev_input_destroy(&b->input); + wl_event_source_remove(b->config_timer); wl_event_source_remove(b->hotplug_timer); wl_event_source_remove(b->udev_drm_source); wl_event_source_remove(b->drm_source); @@ -3483,6 +3497,10 @@ output_create_notify(struct wl_listener *listener, void *data) output_create_listener); drm_backend_update_outputs(b); + + /* Force reload config */ + memset(&b->config_stat, 0, sizeof(b->config_stat)); + config_timer_handler(b); } static const struct weston_drm_output_api api = { @@ -3491,6 +3509,236 @@ static const struct weston_drm_output_api api = { drm_output_set_seat, }; +static void +drm_output_rotate(struct drm_output *output, int rotate) +{ + struct drm_backend *b = to_drm_backend(output->base.compositor); + uint32_t transform = output->original_transform; + struct timespec now; + + /* Hacky way to rotate transform */ + transform = (transform / 4) * 4 + (transform + rotate) % 4; + + if (output->base.transform == transform) + return; + + /* Freeze output when rotating */ + weston_compositor_read_presentation_clock(b->compositor, &now); + output->last_resize_ms = timespec_to_msec(&now); + + weston_output_set_transform(&output->base, transform); +} + +static void +drm_output_modeset(struct drm_output *output, const char *modeline) +{ + struct drm_backend *b = to_drm_backend(output->base.compositor); + struct drm_head *head = + to_drm_head(weston_output_get_first_head(&output->base)); + struct drm_mode *mode; + struct timespec now; + + /* Unable to switch mode, let's retry later */ + if (output->page_flip_pending || output->atomic_complete_pending) { + memset(&b->config_stat, 0, sizeof(b->config_stat)); + return; + } + + mode = drm_output_choose_initial_mode(b, output, + WESTON_DRM_BACKEND_OUTPUT_PREFERRED, + modeline, + &head->inherited_mode); + + weston_output_mode_set_native(&output->base, &mode->base, + output->base.current_scale); + weston_output_damage(&output->base); + + mode = to_drm_mode(output->base.current_mode); + + weston_log("Output %s changed to %dx%d@%d for mode(%s)\n", + output->base.name, + mode->mode_info.hdisplay, mode->mode_info.vdisplay, + mode->mode_info.vrefresh, + modeline); + + weston_compositor_read_presentation_clock(b->compositor, &now); + b->last_update_ms = timespec_to_msec(&now); +} + +static void +drm_output_set_size(struct drm_output *output, const int w, const int h) +{ + struct drm_backend *b = to_drm_backend(output->base.compositor); + struct weston_mode *mode; + struct timespec now; + + if (output->base.fixed_size && + output->base.current_mode->width == w && + output->base.current_mode->height == h) + return; + + wl_list_for_each(mode, &output->base.mode_list, link) { + mode->width = w; + mode->height = h; + } + + output->base.fixed_size = true; + + /* Freeze output when resizing */ + weston_compositor_read_presentation_clock(b->compositor, &now); + output->last_resize_ms = timespec_to_msec(&now); + + weston_output_set_transform(&output->base, output->base.transform); + + if (b->use_pixman) { + drm_output_fini_pixman(output); + if (drm_output_init_pixman(output, b) < 0) + weston_log("failed to init output pixman state with " + "new mode\n"); + } else { + drm_output_fini_egl(output); + if (drm_output_init_egl(output, b) < 0) + weston_log("failed to init output egl state with " + "new mode"); + } + + drm_output_print_modes(output); +} + +static void +config_handle_output(struct drm_backend *b, const char *name, + const char *config) +{ + struct drm_output *output; + bool is_all = !strcmp(name, "all"); + + wl_list_for_each(output, &b->compositor->output_list, base.link) { + if (!is_all && strcmp(name, output->base.name)) + continue; + + if (!strcmp(config, "primary")) { + setenv("WESTON_DRM_PRIMARY", name, 1); + hotplug_timer_handler(b); + } else if (!strcmp(config, "prefer")) { + b->compositor->prefer_output = &output->base; + } else if (!strncmp(config, "rotate", strlen("rotate"))) { + int rotate = atoi(config + strlen("rotate")) / 90; + drm_output_rotate(output, rotate); + } else if (!strncmp(config, "mode=", strlen("mode="))) { + drm_output_modeset(output, config + strlen("mode=")); + } else if (!strcmp(config, "freeze")) { + output->base.freezing = true; + } else if (!strcmp(config, "off")) { + output->base.freezing = true; + if (!output->virtual) + drm_set_dpms(&output->base, WESTON_DPMS_OFF); + } else if (!strcmp(config, "unfreeze") || + !strcmp(config, "on")) { + if (!output->base.freezing) + continue; + + output->base.freezing = false; + + if (!output->virtual) + drm_set_dpms(&output->base, WESTON_DPMS_ON); + + drm_output_update_complete(output, 0, 0, 0); + output->page_flip_pending = false; + output->atomic_complete_pending = false; + + weston_output_damage(&output->base); + } else if (!strncmp(config, "down-scale=", + strlen("down-scale="))) { + double down_scale = + atof(config + strlen("down-scale=")); + if (down_scale == output->base.down_scale || + down_scale < 0.125 || down_scale > 1) + continue; + + output->base.down_scale = down_scale; + weston_output_damage(&output->base); + } else if (!strncmp(config, "size=", strlen("size="))) { + int w, h; + + if (sscanf(config, "size=%dx%d", &w, &h) != 2) + continue; + + drm_output_set_size(output, w, h); + } else if (!strncmp(config, "pos=", strlen("pos="))) { + int x, y; + + if (sscanf(config, "pos=%d,%d", &x, &y) != 2) + continue; + + weston_output_move(&output->base, x, y); + output->base.fixed_position = true; + + weston_compositor_reflow_outputs(b->compositor); + } else if (!strncmp(config, "rect=", strlen("rect="))) { + int x1, y1, x2, y2, ret; + + ret = sscanf(config, "rect=<%d,%d,%d,%d>", + &x1, &y1, &x2, &y2); + if (ret != 4) + continue; + + output->plane_bounds.x1 = x1; + output->plane_bounds.y1 = y1; + output->plane_bounds.x2 = x2; + output->plane_bounds.y2 = y2; + weston_output_schedule_repaint(&output->base); + } + } +} + +static int +config_timer_handler(void *data) +{ +#define MAX_CONF_LEN 32 +#define _STR(x) #x +#define STR(x) _STR(x) + + struct drm_backend *b = data; + struct stat st; + char type[MAX_CONF_LEN], key[MAX_CONF_LEN], value[MAX_CONF_LEN]; + const char *config_file; + FILE *conf_fp; + + wl_event_source_timer_update(b->config_timer, DRM_CONFIG_UPDATE_MS); + + config_file = getenv("WESTON_DRM_CONFIG"); + if (!config_file) + config_file = WESTON_DRM_CONFIG_FILE; + + if (stat(config_file, &st) < 0) + return 0; + + if (st.st_mtime && !memcmp(&st, &b->config_stat, sizeof(st))) + return 0; + + conf_fp = fopen(config_file, "r"); + if (!conf_fp) + return 0; + + /** + * Parse configs, formated with :: + * For example: "output:all:rotate90" + */ + while (3 == fscanf(conf_fp, + "%" STR(MAX_CONF_LEN) "[^:]:" + "%" STR(MAX_CONF_LEN) "[^:]:" + "%" STR(MAX_CONF_LEN) "s ", type, key, value)) { + if (!strcmp(type, "output")) + config_handle_output(b, key, value); + } + + fclose(conf_fp); + + stat(config_file, &st); + b->config_stat = st; + return 0; +} + enum drm_head_mode { DRM_HEAD_MODE_DEFAULT, DRM_HEAD_MODE_PRIMARY, @@ -3830,6 +4078,10 @@ drm_backend_create(struct weston_compositor *compositor, b->hotplug_timer = wl_event_loop_add_timer(loop, hotplug_timer_handler, b); + b->config_timer = + wl_event_loop_add_timer(loop, config_timer_handler, b); + config_timer_handler(b); + return b; err_udev_monitor: diff --git a/libweston/backend-drm/modes.c b/libweston/backend-drm/modes.c index e7bbfa5..ff7421d 100644 --- a/libweston/backend-drm/modes.c +++ b/libweston/backend-drm/modes.c @@ -385,15 +385,19 @@ drm_output_add_mode(struct drm_output *output, const drmModeModeInfo *info) if (mode == NULL) return NULL; - mode->base.flags = 0; - mode->base.width = info->hdisplay; - mode->base.height = info->vdisplay; - - if (b->virtual_width && b->virtual_height) { + if (output->base.fixed_size) { + mode->base.width = output->base.width; + mode->base.height = output->base.height; + } else if (b->virtual_width && b->virtual_height) { mode->base.width = b->virtual_width; mode->base.height = b->virtual_height; + } else { + mode->base.width = info->hdisplay; + mode->base.height = info->vdisplay; } + mode->base.flags = 0; + mode->base.refresh = drm_refresh_rate_mHz(info); mode->mode_info = *info; mode->blob_id = 0; @@ -566,7 +570,7 @@ update_head_from_connector(struct drm_head *head) * @param current_mode Mode currently being displayed on this output * @returns A mode from the output's mode list, or NULL if none available */ -static struct drm_mode * +struct drm_mode * drm_output_choose_initial_mode(struct drm_backend *backend, struct drm_output *output, enum weston_drm_backend_output_mode mode, @@ -619,8 +623,8 @@ drm_output_choose_initial_mode(struct drm_backend *backend, } wl_list_for_each_reverse(drm_mode, &output->base.mode_list, base.link) { - if (width == drm_mode->base.width && - height == drm_mode->base.height && + if (width == drm_mode->mode_info.hdisplay && + height == drm_mode->mode_info.vdisplay && (refresh == 0 || refresh == drm_mode->mode_info.vrefresh)) { if (!backend->aspect_ratio_supported || aspect_ratio == drm_mode->base.aspect_ratio) diff --git a/libweston/compositor.c b/libweston/compositor.c index 7680445..0aa9d1a 100644 --- a/libweston/compositor.c +++ b/libweston/compositor.c @@ -3009,6 +3009,11 @@ weston_output_repaint(struct weston_output *output, void *repaint_data) static void weston_output_schedule_repaint_reset(struct weston_output *output) { + if (output->idle_repaint_source) { + wl_event_source_remove(output->idle_repaint_source); + output->idle_repaint_source = NULL; + } + output->repaint_status = REPAINT_NOT_SCHEDULED; TL_POINT(output->compositor, "core_repaint_exit_loop", TLP_OUTPUT(output), TLP_END); @@ -3022,6 +3027,11 @@ weston_output_maybe_repaint(struct weston_output *output, struct timespec *now, int ret = 0; int64_t msec_to_repaint; + /* If we're sleeping, drop the repaint machinery entirely; we will + * explicitly repaint it when we come back. */ + if (output->freezing) + goto err; + /* We're not ready yet; come back to make a decision later. */ if (output->repaint_status != REPAINT_SCHEDULED) return ret; @@ -3048,11 +3058,11 @@ weston_output_maybe_repaint(struct weston_output *output, struct timespec *now, * output. */ ret = weston_output_repaint(output, repaint_data); weston_compositor_read_presentation_clock(compositor, now); - if (ret != 0) + if (ret < 0) goto err; - output->repainted = true; - return ret; + output->repainted = !ret; + return 0; err: weston_output_schedule_repaint_reset(output); @@ -3105,7 +3115,7 @@ output_repaint_timer_handler(void *data) struct weston_output *output; struct timespec now; void *repaint_data = NULL; - int ret = 0; + int ret = 0, repainted = 0; if (!access(getenv("WESTON_FREEZE_DISPLAY") ? : "", F_OK)) { usleep(DEFAULT_REPAINT_WINDOW * 1000); @@ -3122,9 +3132,11 @@ output_repaint_timer_handler(void *data) ret = weston_output_maybe_repaint(output, &now, repaint_data); if (ret) break; + + repainted |= output->repainted; } - if (ret == 0) { + if (ret == 0 && repainted) { if (compositor->backend->repaint_flush) ret = compositor->backend->repaint_flush(compositor, repaint_data); @@ -6099,7 +6111,7 @@ weston_compositor_reflow_outputs(struct weston_compositor *compositor) wl_list_for_each(head, &output->head_list, output_link) weston_head_update_global(head); - if (!weston_output_valid(output)) + if (!weston_output_valid(output) || output->fixed_position) continue; x = next_x; @@ -6546,6 +6558,9 @@ weston_output_set_transform(struct weston_output *output, weston_compositor_reflow_outputs(output->compositor); + wl_signal_emit(&output->compositor->output_resized_signal, + output); + /* Notify clients of the change for output transform. */ wl_list_for_each(head, &output->head_list, output_link) { wl_resource_for_each(resource, &head->resource_list) { @@ -6678,6 +6693,8 @@ weston_output_init(struct weston_output *output, /* Can't use -1 on uint32_t and 0 is valid enum value */ output->transform = UINT32_MAX; + output->down_scale = 1.0f; + pixman_region32_init(&output->region); wl_list_init(&output->mode_list); } @@ -6769,11 +6786,8 @@ weston_output_create_heads_string(struct weston_output *output) WL_EXPORT int weston_output_enable(struct weston_output *output) { - struct weston_compositor *c = output->compositor; - struct weston_output *iterator; struct weston_head *head; char *head_names; - int x = 0, y = 0; if (output->enabled) { weston_log("Error: attempt to enable an enabled output '%s'\n", @@ -6798,20 +6812,17 @@ weston_output_enable(struct weston_output *output) assert(head->model); } - iterator = container_of(c->output_list.prev, - struct weston_output, link); - - if (!wl_list_empty(&c->output_list)) - x = iterator->x + iterator->width; - /* Make sure the scale is set up */ assert(output->scale); /* Make sure we have a transform set */ assert(output->transform != UINT32_MAX); - output->x = x; - output->y = y; + if (!output->fixed_position) { + output->x = 0; + output->y = 0; + } + output->original_scale = output->scale; wl_signal_init(&output->frame_signal); @@ -6820,8 +6831,7 @@ weston_output_enable(struct weston_output *output) weston_output_transform_scale_init(output, output->transform, output->scale); weston_output_init_zoom(output); - weston_output_init_geometry(output, x, y); - weston_output_damage(output); + weston_output_init_geometry(output, output->x, output->y); wl_list_init(&output->animation_list); wl_list_init(&output->feedback_list); @@ -6848,6 +6858,8 @@ weston_output_enable(struct weston_output *output) output->name, head_names); free(head_names); + weston_compositor_reflow_outputs(output->compositor); + return 0; } diff --git a/libweston/pixman-renderer.c b/libweston/pixman-renderer.c index 754adce..d7182e7 100644 --- a/libweston/pixman-renderer.c +++ b/libweston/pixman-renderer.c @@ -158,6 +158,9 @@ pixman_renderer_compute_transform(pixman_transform_t *transform_out, specified buffer transform/scale */ matrix = output->inverse_matrix; + weston_matrix_scale(&matrix, + 1 / output->down_scale, 1 / output->down_scale, 1); + if (ev->transform.enabled) { weston_matrix_multiply(&matrix, &ev->transform.inverse); } else { diff --git a/libweston/renderer-gl/gl-renderer.c b/libweston/renderer-gl/gl-renderer.c index 6e04baa..f853149 100644 --- a/libweston/renderer-gl/gl-renderer.c +++ b/libweston/renderer-gl/gl-renderer.c @@ -1720,6 +1720,10 @@ gl_renderer_repaint_output(struct weston_output *output, /* Calculate the global GL matrix */ go->output_matrix = output->matrix; + + weston_matrix_scale(&go->output_matrix, + output->down_scale, output->down_scale, 1); + weston_matrix_translate(&go->output_matrix, -(output->current_mode->width / 2.0), -(output->current_mode->height / 2.0), 0); -- 2.20.1