| // Copyright 2022 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <math.h> |
| #include <type_traits> |
| |
| #include "sommelier-tracing.h" // NOLINT(build/include_directory) |
| #include "sommelier-transform.h" // NOLINT(build/include_directory) |
| |
| namespace { |
| |
| template < |
| typename T, |
| typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> |
| void stable_scale_host_to_guest(T* value, double scale) { |
| *value = static_cast<T>(ceil(static_cast<double>(*value) * scale)); |
| } |
| |
| template < |
| typename T, |
| typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> |
| void stable_scale_size_host_to_guest(T* value, double scale) { |
| *value = static_cast<T>(floor(static_cast<double>(*value) * scale)); |
| } |
| |
| template < |
| typename T, |
| typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> |
| void stable_scale_guest_to_host(T* value, double scale) { |
| *value = static_cast<T>(floor(static_cast<double>(*value) / scale)); |
| } |
| |
| template < |
| typename T, |
| typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> |
| void stable_scale_size_guest_to_host(T* value, double scale) { |
| *value = static_cast<T>(ceil(static_cast<double>(*value) / scale)); |
| } |
| |
| } // namespace |
| |
| static void sl_transform_get_scale_factors( |
| struct sl_context* ctx, |
| const struct sl_host_surface* surface, |
| double* scalex, |
| double* scaley) { |
| if (ctx->use_direct_scale && surface && surface->has_own_scale) { |
| *scalex = surface->xdg_scale_x; |
| *scaley = surface->xdg_scale_y; |
| } else if (surface && surface->output) { |
| *scalex = surface->output.get()->xdg_scale_x; |
| *scaley = surface->output.get()->xdg_scale_y; |
| } else { |
| *scalex = ctx->xdg_scale_x; |
| *scaley = ctx->xdg_scale_y; |
| } |
| } |
| |
| static double sl_transform_direct_axis_scale(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| uint32_t axis) { |
| double scalex, scaley; |
| |
| sl_transform_get_scale_factors(ctx, surface, &scalex, &scaley); |
| return (axis == 0) ? scaley : scalex; |
| } |
| |
| static void sl_transform_direct_to_host_damage( |
| struct sl_context* ctx, |
| const struct sl_host_surface* surface, |
| int64_t* x, |
| int64_t* y, |
| double scale_x, |
| double scale_y) { |
| if (ctx->stable_scaling) { |
| stable_scale_guest_to_host(x, scale_x); |
| stable_scale_guest_to_host(y, scale_y); |
| } else { |
| double x_whole = trunc(static_cast<double>(*x) / scale_x); |
| double y_whole = trunc(static_cast<double>(*y) / scale_y); |
| |
| *x = static_cast<int64_t>(x_whole); |
| *y = static_cast<int64_t>(y_whole); |
| } |
| } |
| |
| static void sl_transform_direct_to_guest_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* coord, |
| uint32_t axis) { |
| double scale = sl_transform_direct_axis_scale(ctx, surface, axis); |
| double result = wl_fixed_to_double(*coord); |
| result *= scale; |
| |
| *coord = wl_fixed_from_double(result); |
| } |
| |
| static void sl_transform_direct_to_guest_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* x, |
| wl_fixed_t* y) { |
| double scale_x, scale_y; |
| double result_x = wl_fixed_to_double(*x); |
| double result_y = wl_fixed_to_double(*y); |
| |
| sl_transform_get_scale_factors(ctx, surface, &scale_x, &scale_y); |
| |
| result_x *= scale_x; |
| result_y *= scale_y; |
| |
| *x = wl_fixed_from_double(result_x); |
| *y = wl_fixed_from_double(result_y); |
| } |
| |
| static void sl_transform_direct_to_host_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* coord, |
| uint32_t axis) { |
| double scale = sl_transform_direct_axis_scale(ctx, surface, axis); |
| double result = wl_fixed_to_double(*coord); |
| |
| result /= scale; |
| |
| *coord = wl_fixed_from_double(result); |
| } |
| |
| static void sl_transform_direct_to_host_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* x, |
| wl_fixed_t* y) { |
| double scale_x, scale_y; |
| |
| sl_transform_get_scale_factors(ctx, surface, &scale_x, &scale_y); |
| |
| double result_x = wl_fixed_to_double(*x); |
| double result_y = wl_fixed_to_double(*y); |
| |
| result_x /= scale_x; |
| result_y /= scale_y; |
| |
| *x = wl_fixed_from_double(result_x); |
| *y = wl_fixed_from_double(result_y); |
| } |
| |
| static void sl_transform_direct_to_guest(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| int32_t* x, |
| int32_t* y) { |
| double scale_x, scale_y; |
| |
| sl_transform_get_scale_factors(ctx, surface, &scale_x, &scale_y); |
| |
| if (ctx->stable_scaling) { |
| stable_scale_host_to_guest(x, scale_x); |
| stable_scale_host_to_guest(y, scale_y); |
| } else { |
| double input_x = static_cast<double>(*x) * scale_x; |
| double input_y = static_cast<double>(*y) * scale_y; |
| |
| double x_whole = (surface && surface->scale_round_on_x) ? lround(input_x) |
| : trunc(input_x); |
| |
| double y_whole = (surface && surface->scale_round_on_y) ? lround(input_y) |
| : trunc(input_y); |
| |
| *x = static_cast<int32_t>(x_whole); |
| *y = static_cast<int32_t>(y_whole); |
| } |
| } |
| |
| static void sl_transform_direct_to_host(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| int32_t* x, |
| int32_t* y) { |
| double scale_x, scale_y; |
| |
| sl_transform_get_scale_factors(ctx, surface, &scale_x, &scale_y); |
| |
| if (ctx->stable_scaling) { |
| stable_scale_guest_to_host(x, scale_x); |
| stable_scale_guest_to_host(y, scale_y); |
| } else { |
| double x_whole = trunc(static_cast<double>(*x) / scale_x); |
| double y_whole = trunc(static_cast<double>(*y) / scale_y); |
| |
| *x = static_cast<int32_t>(x_whole); |
| *y = static_cast<int32_t>(y_whole); |
| } |
| } |
| |
| bool sl_transform_viewport_scale(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| double contents_scale, |
| int32_t* width, |
| int32_t* height) { |
| double scale = ctx->scale * contents_scale; |
| |
| // TODO(mrisaacb): It may be beneficial to skip the set_destination call |
| // when the virtual and logical space match. |
| bool do_viewport = true; |
| |
| if (surface && surface->window && surface->window->viewport_override) { |
| *width = surface->window->viewport_width; |
| *height = surface->window->viewport_height; |
| } else if (ctx->use_direct_scale) { |
| sl_transform_direct_to_host(ctx, surface, width, height); |
| |
| // For very small windows (in pixels), the resulting logical dimensions |
| // could be 0, which will cause issues with the viewporter interface. |
| // |
| // In these cases, fix it up here by forcing the logical output |
| // to be at least 1 pixel |
| |
| if (*width <= 0) |
| *width = 1; |
| |
| if (*height <= 0) |
| *height = 1; |
| |
| } else { |
| if (ctx->stable_scaling) { |
| stable_scale_size_guest_to_host(width, scale); |
| stable_scale_size_guest_to_host(height, scale); |
| } else { |
| *width = ceil(*width / scale); |
| *height = ceil(*height / scale); |
| } |
| } |
| |
| return do_viewport; |
| } |
| |
| void sl_transform_damage_coord(struct sl_context* ctx, |
| const struct sl_host_surface* surface, |
| double buffer_scalex, |
| double buffer_scaley, |
| int64_t* x1, |
| int64_t* y1, |
| int64_t* x2, |
| int64_t* y2) { |
| if (ctx->use_direct_scale) { |
| double scalex, scaley; |
| |
| sl_transform_get_scale_factors(ctx, surface, &scalex, &scaley); |
| |
| scalex *= buffer_scalex; |
| scaley *= buffer_scaley; |
| |
| sl_transform_direct_to_host_damage(ctx, surface, x1, y1, scalex, scaley); |
| sl_transform_direct_to_host_damage(ctx, surface, x2, y2, scalex, scaley); |
| } else { |
| double sx = buffer_scalex * ctx->scale; |
| double sy = buffer_scaley * ctx->scale; |
| |
| // Enclosing rect after scaling and outset by one pixel to account for |
| // potential filtering. |
| *x1 = MAX(MIN_SIZE, (*x1) - 1) / sx; |
| *y1 = MAX(MIN_SIZE, (*y1) - 1) / sy; |
| *x2 = ceil(MIN((*x2) + 1, MAX_SIZE) / sx); |
| *y2 = ceil(MIN((*y2) + 1, MAX_SIZE) / sy); |
| } |
| } |
| |
| void sl_transform_host_to_guest(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| int32_t* x, |
| int32_t* y) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_guest(ctx, surface, x, y); |
| } else { |
| if (ctx->stable_scaling) { |
| stable_scale_host_to_guest(x, ctx->scale); |
| stable_scale_host_to_guest(y, ctx->scale); |
| } else { |
| (*x) *= ctx->scale; |
| (*y) *= ctx->scale; |
| } |
| } |
| } |
| |
| void sl_transform_host_to_guest_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* x, |
| wl_fixed_t* y) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_guest_fixed(ctx, surface, x, y); |
| } else { |
| double dx = wl_fixed_to_double(*x); |
| double dy = wl_fixed_to_double(*y); |
| |
| dx *= ctx->scale; |
| dy *= ctx->scale; |
| |
| *x = wl_fixed_from_double(dx); |
| *y = wl_fixed_from_double(dy); |
| } |
| } |
| |
| void sl_transform_pointer(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* x, |
| wl_fixed_t* y) { |
| sl_transform_host_to_guest_fixed(ctx, surface, x, y); |
| if (surface && surface->window && surface->window->viewport_override) { |
| double dx = wl_fixed_to_double(*x); |
| double dy = wl_fixed_to_double(*y); |
| dx *= surface->window->viewport_pointer_scale; |
| dy *= surface->window->viewport_pointer_scale; |
| *x = wl_fixed_from_double(dx); |
| *y = wl_fixed_from_double(dy); |
| } |
| } |
| |
| void sl_transform_host_to_guest_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* coord, |
| uint32_t axis) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_guest_fixed(ctx, surface, coord, axis); |
| } else { |
| double dx = wl_fixed_to_double(*coord); |
| dx *= ctx->scale; |
| *coord = wl_fixed_from_double(dx); |
| } |
| } |
| |
| void sl_transform_guest_to_host(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| int32_t* x, |
| int32_t* y) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_host(ctx, surface, x, y); |
| } else { |
| if (ctx->stable_scaling) { |
| stable_scale_guest_to_host(x, ctx->scale); |
| stable_scale_guest_to_host(y, ctx->scale); |
| } else { |
| (*x) /= ctx->scale; |
| (*y) /= ctx->scale; |
| } |
| } |
| } |
| |
| void sl_transform_guest_to_host_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* x, |
| wl_fixed_t* y) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_host_fixed(ctx, surface, x, y); |
| } else { |
| double dx = wl_fixed_to_double(*x); |
| double dy = wl_fixed_to_double(*y); |
| |
| dx /= ctx->scale; |
| dy /= ctx->scale; |
| |
| *x = wl_fixed_from_double(dx); |
| *y = wl_fixed_from_double(dy); |
| } |
| } |
| |
| void sl_transform_guest_to_host_fixed(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| wl_fixed_t* coord, |
| uint32_t axis) { |
| if (ctx->use_direct_scale) { |
| sl_transform_direct_to_host_fixed(ctx, surface, coord, axis); |
| } else { |
| double dx = wl_fixed_to_double(*coord); |
| dx /= ctx->scale; |
| *coord = wl_fixed_from_double(dx); |
| } |
| } |
| |
| struct sl_host_output* sl_transform_guest_position_to_host_position( |
| sl_context* ctx, sl_host_surface* surface, int32_t* x, int32_t* y) { |
| sl_host_output* output = sl_infer_output_for_guest_position(ctx, *x, *y); |
| assert(output); |
| |
| // Translate from global to output-relative guest coordinates |
| (*x) -= output->virt_x; |
| |
| // Convert to host logical scale |
| sl_transform_guest_to_host(ctx, surface, x, y); |
| |
| // Translate to global host coordinates |
| (*x) += output->x; |
| (*y) += output->y; |
| |
| return output; |
| } |
| |
| struct sl_host_output* sl_transform_host_position_to_guest_position( |
| sl_context* ctx, sl_host_surface* surface, int32_t* x, int32_t* y) { |
| sl_host_output* output = sl_infer_output_for_host_position(ctx, *x, *y); |
| assert(output); |
| |
| // Translate from global to output-local host coordinates |
| (*x) -= output->x; |
| (*y) -= output->y; |
| |
| // Convert to guest virtual scale |
| sl_transform_host_to_guest(ctx, surface, x, y); |
| |
| // Translate to global guest coordinates |
| (*x) += output->virt_x; |
| |
| return output; |
| } |
| |
| void sl_transform_try_window_scale(struct sl_context* ctx, |
| struct sl_host_surface* surface, |
| int32_t width_in_pixels, |
| int32_t height_in_pixels) { |
| int32_t reverse_width = width_in_pixels; |
| int32_t reverse_height = height_in_pixels; |
| int32_t logical_width; |
| int32_t logical_height; |
| |
| // This function should only have an effect in direct scale mode |
| if (!ctx->use_direct_scale) |
| return; |
| |
| // Reset scale so that calls to sl_transform_get_scale_factors will not |
| // use the current scale. |
| sl_transform_reset_surface_scale(ctx, surface); |
| |
| // Transform the window dimensions using the global/per-output scaling factors |
| sl_transform_guest_to_host(ctx, surface, &reverse_width, &reverse_height); |
| |
| // Save the logical dimensions for later use |
| logical_width = reverse_width; |
| logical_height = reverse_height; |
| |
| // Transform the logical dimensions back to the virtual pixel dimensions |
| sl_transform_host_to_guest(ctx, surface, &reverse_width, &reverse_height); |
| |
| // If the computed logical width or height is zero, force the |
| // use of the global scaling factors |
| |
| if ((reverse_width != width_in_pixels || |
| reverse_height != height_in_pixels) && |
| (logical_width > 0 && logical_height > 0)) { |
| // There is no match, let's override the scaling setting on our surface |
| surface->has_own_scale = 1; |
| surface->xdg_scale_x = static_cast<double>(width_in_pixels) / |
| static_cast<double>(logical_width); |
| surface->xdg_scale_y = static_cast<double>(height_in_pixels) / |
| static_cast<double>(logical_height); |
| |
| surface->cached_logical_height = logical_height; |
| surface->cached_logical_width = logical_width; |
| |
| // Try once more to do a full cycle (pixel -> logical -> pixel), |
| // if we aren't equal, we need to force a round up on the translation |
| // to the guest. |
| |
| reverse_width = width_in_pixels; |
| reverse_height = height_in_pixels; |
| |
| sl_transform_guest_to_host(ctx, surface, &reverse_width, &reverse_height); |
| sl_transform_host_to_guest(ctx, surface, &reverse_width, &reverse_height); |
| |
| if (reverse_width != width_in_pixels) |
| surface->scale_round_on_x = true; |
| |
| if (reverse_height != height_in_pixels) |
| surface->scale_round_on_y = true; |
| } |
| } |
| |
| void sl_transform_reset_surface_scale(struct sl_context* ctx, |
| struct sl_host_surface* surface) { |
| surface->has_own_scale = 0; |
| surface->scale_round_on_x = surface->scale_round_on_y = false; |
| surface->xdg_scale_x = surface->xdg_scale_y = 0; |
| } |
| |
| void sl_transform_output_dimensions(struct sl_context* ctx, |
| int32_t* width, |
| int32_t* height) { |
| if (ctx->stable_scaling) { |
| stable_scale_size_host_to_guest(width, ctx->scale); |
| stable_scale_size_host_to_guest(height, ctx->scale); |
| } else { |
| *width = (*width) * ctx->scale; |
| *height = (*height) * ctx->scale; |
| } |
| } |
