sommelier-output.cc

// 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 "sommelier.h"            // NOLINT(build/include_directory)
#include "sommelier-transform.h"  // NOLINT(build/include_directory)

#include <algorithm>
#include <assert.h>
#include <cstdint>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <wayland-client.h>

#include "aura-shell-client-protocol.h"  // NOLINT(build/include_directory)
#include "xdg-output-unstable-v1-client-protocol.h"  // NOLINT(build/include_directory)

#define MAX_OUTPUT_SCALE 2

#define INCH_IN_MM 25.4

// Legacy X11 applications use DPI to decide on their scale. This value is what
// the convention for a "normal" scale is. One way to verify the convention is
// to note the DPI of a typical monitor circa ~2005, i.e. 20" 1080p.
#define DEFACTO_DPI 96

double sl_output_aura_scale_factor_to_double(int scale_factor) {
  // Aura scale factor is an enum that for all currently know values
  // is a scale value multipled by 1000. For example, enum value for
  // 1.25 scale factor is 1250.
  return scale_factor / 1000.0;
}

int dpi_to_physical_mm(double dpi, int px) {
  return px * (INCH_IN_MM / dpi);
}

void sl_output_apply_rotation(
    int transform, int width, int height, int* out_width, int* out_height) {
  switch (transform) {
    case WL_OUTPUT_TRANSFORM_NORMAL:
    case WL_OUTPUT_TRANSFORM_180:
    case WL_OUTPUT_TRANSFORM_FLIPPED:
    case WL_OUTPUT_TRANSFORM_FLIPPED_180:
      *out_width = width;
      *out_height = height;
      break;

    default:
      *out_width = height;
      *out_height = width;
      break;
  }
}

void sl_output_get_host_output_state(struct sl_host_output* host,
                                     int* scale,
                                     int* physical_width,
                                     int* physical_height,
                                     int* width,
                                     int* height) {
  // The user's chosen zoom level.
  double current_scale =
      sl_output_aura_scale_factor_to_double(host->current_scale);

  // The scale applied to a screen at the default zoom. I.e. this value
  // determines the meaning of "100%" zoom, and how zoom relates to the
  // apparent resolution:
  //
  //    apparent_res = native_res / device_scale_factor * current_scale
  //
  // e.g.: On a device with a DSF of 2.0, 80% zoom really means "apply 1.6x
  // scale", and 50% zoom would give you an apparent resolution equal to the
  // native one.
  double device_scale_factor =
      sl_output_aura_scale_factor_to_double(host->device_scale_factor);

  // Optimistically, we will try to apply the scale that the user chose.
  // Failing that, we will use the scale set for this wl_output.
  double applied_scale = device_scale_factor * current_scale;
  if (!host->ctx->aura_shell) {
    applied_scale = host->scale_factor;
  }

  int target_dpi = DEFACTO_DPI;
  if (host->ctx->xwayland) {
    // For X11, we must fix the scale to be 1 (since X apps typically can't
    // handle scaling). As a result, we adjust the resolution (based on the
    // scale we want to apply and sommelier's configuration) and the physical
    // dimensions (based on what DPI we want the applications to use). E.g.:
    //  - Device scale is 1.25x, with 1920x1080 resolution on a 295mm by 165mm
    //    screen.
    //  - User chosen zoom is 130%
    //  - Sommelier is scaled to 0.5 (a.k.a low density). Since ctx->scale also
    //    has the device scale, it will be 0.625 (i.e. 0.5 * 1.25).
    //  - We want the DPI to be 120 (i.e. 96 * 1.25)
    //     - Meaning 0.21 mm/px
    //  - We report resolution 738x415 (1920x1080 * 0.5 / 1.3)
    //  - We report dimensions 155mm by 87mm (738x415 * 0.21)
    // This is mostly expected, another way of thinking about them is that zoom
    // and scale modify the application's understanding of length:
    //  - Increasing the zoom makes lengths appear longer (i.e. fewer mm to work
    //    with over the same real length).
    //  - Scaling the screen does the inverse.
    if (scale)
      *scale = 1;
    *width = host->width * host->ctx->scale / applied_scale;
    *height = host->height * host->ctx->scale / applied_scale;

    target_dpi = DEFACTO_DPI * device_scale_factor;
    *physical_width = dpi_to_physical_mm(target_dpi, *width);
    *physical_height = dpi_to_physical_mm(target_dpi, *height);
  } else {
    // For wayland, we directly apply the scale which combines the user's chosen
    // preference (from aura) and the scale which this sommelier was configured
    // for (i.e. based on ctx->scale, which comes from the env/cmd line).
    //
    // See above comment: ctx->scale already has the device_scale_factor in it,
    // so this maths actually looks like:
    //
    //              applied / ctx->scale
    //      = (current*DSF) / (config*DSF)
    //      =       current / config
    //
    // E.g. if we configured sommelier to scale everything 0.5x, and the user
    // has chosen 130% zoom, we are applying 2.6x scale factor.
    int s = MIN(ceil(applied_scale / host->ctx->scale), MAX_OUTPUT_SCALE);

    if (scale)
      *scale = s;
    *physical_width = host->physical_width;
    *physical_height = host->physical_height;
    *width = host->width * host->ctx->scale * s / applied_scale;
    *height = host->height * host->ctx->scale * s / applied_scale;
    target_dpi = (*width * INCH_IN_MM) / *physical_width;
  }

  if (host->ctx->dpi.size) {
    int adjusted_dpi = *(reinterpret_cast<int*>(host->ctx->dpi.data));

    // Choose the DPI bucket which is closest to the target DPI which we
    // calculated above.
    int* dpi;
    sl_array_for_each(dpi, &host->ctx->dpi) {
      if (abs(*dpi - target_dpi) < abs(adjusted_dpi - target_dpi))
        adjusted_dpi = *dpi;
    }

    *physical_width = dpi_to_physical_mm(adjusted_dpi, *width);
    *physical_height = dpi_to_physical_mm(adjusted_dpi, *height);
  }
}

void sl_output_get_logical_dimensions(struct sl_host_output* host,
                                      bool rotated,
                                      int32_t* width,
                                      int32_t* height) {
  if (rotated) {
    // Pass the dimensions as is (it could be rotated)
    *width = host->logical_width;
    *height = host->logical_height;
  } else {
    // The transform here indicates how a window image will be
    // rotated when composited. The incoming surface from the
    // application will NOT have its dimensions rotated.
    // For this reason, in order to calculate the scale factors
    // for direct scale, we will need the non rotated logical
    // dimensions.

    sl_output_apply_rotation(host->transform, host->logical_width,
                             host->logical_height, width, height);
  }
}

void sl_output_init_dimensions_direct(struct sl_host_output* host,
                                      int* out_scale,
                                      int* out_physical_width,
                                      int* out_physical_height,
                                      int* out_width,
                                      int* out_height) {
  int32_t virtual_width = host->width;
  int32_t virtual_height = host->height;

  // This requires xdg_output_manager, it is assumed that it will be
  // available and we will have an appropriate set of logical dimensions
  // for this particular output.
  assert(host->ctx->viewporter);
  assert(host->ctx->xdg_output_manager);

  // The virtual width/height is computed by this function here based
  // on the physical width/height
  sl_transform_output_dimensions(host->ctx, &virtual_width, &virtual_height);

  host->virt_scale_x = static_cast<double>(virtual_width) / host->width;
  host->virt_scale_y = static_cast<double>(virtual_height) / host->height;

  *out_width = virtual_width;
  *out_height = virtual_height;

  // Force the scale to 1
  //
  // This is reported to the guest through the wl_output protocol.
  // This value will signal by how much a compositor will upscale
  // all buffers by (1 is no scale).
  *out_scale = 1;

  // The physical dimensions (in mm) are the same, regardless
  // of the provided scale factor.
  *out_physical_width = host->physical_width;
  *out_physical_height = host->physical_height;

  // Retrieve the logical dimensions
  int32_t logical_width, logical_height;

  sl_output_get_logical_dimensions(host, /*rotated=*/false, &logical_width,
                                   &logical_height);

  // We want to be able to transform from virtual to XDG logical
  // coordinates
  // Virt to XDG -> div
  // XDG to Virt -> mul
  host->xdg_scale_x =
      static_cast<double>(virtual_width) / static_cast<double>(logical_width);
  host->xdg_scale_y =
      static_cast<double>(virtual_height) / static_cast<double>(logical_height);

  if (host->internal) {
    host->ctx->virt_scale_x = host->virt_scale_x;
    host->ctx->virt_scale_y = host->virt_scale_y;
    host->ctx->xdg_scale_x = host->xdg_scale_x;
    host->ctx->xdg_scale_y = host->xdg_scale_y;
  }
}

void sl_output_get_dimensions_original(struct sl_host_output* host,
                                       int* out_scale,
                                       int* out_physical_width,
                                       int* out_physical_height,
                                       int* out_width,
                                       int* out_height) {
  int scale;
  int physical_width;
  int physical_height;
  int width;
  int height;

  sl_output_get_host_output_state(host, &scale, &physical_width,
                                  &physical_height, &width, &height);

  // Use density of internal display for all Xwayland outputs. X11 clients
  // typically lack support for dynamically changing density so it's
  // preferred to always use the density of the internal display.
  if (host->ctx->xwayland) {
    for (auto output : host->ctx->host_outputs) {
      if (output->internal) {
        int internal_width;
        int internal_height;

        sl_output_get_host_output_state(output, nullptr, &physical_width,
                                        &physical_height, &internal_width,
                                        &internal_height);

        physical_width = (physical_width * width) / internal_width;
        physical_height = (physical_height * height) / internal_height;
        break;
      }
    }
  }

  *out_scale = scale;
  *out_physical_width = physical_width;
  *out_physical_height = physical_height;
  *out_width = width;
  *out_height = height;
}

// Recalculates the virt_x coordinates of outputs when an output is
// add/removed/changed.
void sl_output_update_output_x(struct sl_context* ctx) {
  // Outputs are positioned in a line from left to right based off their x
  // position.
  int next_output_x = 0;
  for (auto output : ctx->host_outputs) {
    // Update the value and mark for sending.
    if (output->virt_x != next_output_x) {
      output->virt_x = next_output_x;
      output->needs_update = true;
    }
    next_output_x += output->virt_rotated_width;
  }
}

struct sl_host_output* sl_infer_output_for_host_position(struct sl_context* ctx,
                                                         int32_t host_x,
                                                         int32_t host_y) {
  struct sl_host_output* closest = nullptr;
  int32_t closest_distance = INT32_MAX;

  // Return the output containing, or closest to, the query X/Y coordinates
  // in host logical space. "Closest" considers Manhattan distance.
  for (auto output : ctx->host_outputs) {
    if (!closest) {
      closest = output;
    }
    int32_t x_distance;
    if (host_x < output->x) {
      // Query point is left of the output
      x_distance = output->x - host_x;
    } else if (host_x < output->x + output->width) {
      // Query point is inside the output (on X axis)
      x_distance = 0;
    } else {
      // Query point is right of the output
      x_distance = host_x - (output->x + output->width);
    }
    int32_t y_distance;
    if (host_y < output->y) {
      // Query point is above the output
      y_distance = output->y - host_y;
    } else if (host_y < output->y + output->height) {
      // Query point is inside the output (on Y axis)
      y_distance = 0;
    } else {
      // Query point is below the output
      y_distance = host_y - (output->y + output->height);
    }
    if (x_distance + y_distance < closest_distance) {
      closest = output;
      closest_distance = x_distance + y_distance;
      if (closest_distance == 0) {
        break;
      }
    }
  }
  return closest;
}

struct sl_host_output* sl_infer_output_for_guest_position(
    struct sl_context* ctx, int32_t virt_x, int32_t virt_y) {
  struct sl_host_output* first = nullptr;
  struct sl_host_output* last = nullptr;

  // Return the output containing the query X coordinate (in virtual space).
  // Since outputs are placed in a horizontal line in virtual space, we can
  // ignore the Y coordinate entirely.
  for (auto output : ctx->host_outputs) {
    if (!first) {
      first = output;
    }
    last = output;
    if (virt_x >= output->virt_x && virt_x < output->virt_x + output->width) {
      return output;
    }
  }

  // The query X coordinate is out of bounds, so return the "nearest" output.
  if (first && virt_x < first->virt_x) {
    return first;
  }
  return last;
}

void sl_output_calculate_virtual_dimensions(struct sl_host_output* host) {
  int scale;
  int virt_physical_width;
  int virt_physical_height;
  int virt_width;
  int virt_height;

  if (host->ctx->use_direct_scale) {
    sl_output_init_dimensions_direct(host, &scale, &virt_physical_width,
                                     &virt_physical_height, &virt_width,
                                     &virt_height);
  } else {
    sl_output_get_dimensions_original(host, &scale, &virt_physical_width,
                                      &virt_physical_height, &virt_width,
                                      &virt_height);
  }

  host->scale_factor = scale;
  host->virt_width = virt_width;
  host->virt_height = virt_height;
  host->virt_physical_width = virt_physical_width;
  host->virt_physical_height = virt_physical_height;

  sl_output_apply_rotation(host->transform, virt_width, virt_height,
                           &host->virt_rotated_width,
                           &host->virt_rotated_height);
  host->needs_update = true;
}

// Function which pushes the state of an output to the client.
void sl_output_send_host_output_state(struct sl_host_output* host) {
  // Could be more granular, but the current implementation means that if one
  // value changes, everything should be impacted.
  if (host->needs_update) {
    wl_output_send_geometry(host->resource, host->virt_x, 0,
                            host->virt_physical_width,
                            host->virt_physical_height, host->subpixel,
                            host->make, host->model, host->transform);
    wl_output_send_mode(host->resource, host->flags | WL_OUTPUT_MODE_CURRENT,
                        host->virt_width, host->virt_height, host->refresh);
    if (wl_resource_get_version(host->resource) >=
        WL_OUTPUT_SCALE_SINCE_VERSION)
      wl_output_send_scale(host->resource, host->scale_factor);
    if (wl_resource_get_version(host->resource) >= WL_OUTPUT_DONE_SINCE_VERSION)
      wl_output_send_done(host->resource);
    host->needs_update = false;
  }
}

static void sl_output_geometry(void* data,
                               struct wl_output* output,
                               int x,
                               int y,
                               int physical_width,
                               int physical_height,
                               int subpixel,
                               const char* make,
                               const char* model,
                               int transform) {
  void* result = wl_output_get_user_data(output);
  sl_host_output* host = static_cast<sl_host_output*>(result);

  host->x = x;
  host->y = y;
  host->physical_width = physical_width;
  host->physical_height = physical_height;
  host->subpixel = subpixel;
  free(host->model);
  host->model = strdup(model);
  free(host->make);
  host->make = strdup(make);
  host->transform = transform;
  auto pointer = std::find(host->ctx->host_outputs.begin(),
                           host->ctx->host_outputs.end(), host);
  assert(pointer != host->ctx->host_outputs.end());
  // host_outputs is sorted by x. Delete then re-insert at the correct
  // position.
  host->ctx->host_outputs.erase(pointer);
  // Insert at the end by default. If insert_at is not set in the loop,
  // hosts's x is larger than all the ones in the list currently.
  auto insert_at = host->ctx->host_outputs.end();
  for (auto it = host->ctx->host_outputs.begin();
       it != host->ctx->host_outputs.end(); ++it) {
    if ((*it)->x > host->x) {
      insert_at = it;
      break;
    }
  }
  host->ctx->host_outputs.insert(insert_at, host);
}

static void sl_output_mode(void* data,
                           struct wl_output* output,
                           uint32_t flags,
                           int width,
                           int height,
                           int refresh) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(wl_output_get_user_data(output));

  host->flags = flags;
  host->width = width;
  host->height = height;
  host->refresh = refresh;
  host->needs_update = true;
}

static void sl_output_done(void* data, struct wl_output* output) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(wl_output_get_user_data(output));

  // Early out if scale is expected but not yet know.
  if (host->expecting_scale)
    return;

  // Recalculate according to any information that's been modified.
  sl_output_calculate_virtual_dimensions(host);
  // Shift all outputs that are to the right of host to the right if needed.
  sl_output_update_output_x(host->ctx);
  sl_output_send_host_output_state(host);

  // Expect scale if aura output exists.
  if (host->aura_output)
    host->expecting_scale = 1;
}

static void sl_output_scale(void* data,
                            struct wl_output* output,
                            int32_t scale_factor) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(wl_output_get_user_data(output));

  host->scale_factor = scale_factor;
}

static const struct wl_output_listener sl_output_listener = {
    sl_output_geometry, sl_output_mode, sl_output_done, sl_output_scale};

static void sl_aura_output_scale(void* data,
                                 struct zaura_output* output,
                                 uint32_t flags,
                                 uint32_t scale) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(zaura_output_get_user_data(output));

  if (flags & ZAURA_OUTPUT_SCALE_PROPERTY_CURRENT)
    host->current_scale = scale;
  if (flags & ZAURA_OUTPUT_SCALE_PROPERTY_PREFERRED)
    host->preferred_scale = scale;

  host->expecting_scale = 0;
}

static void sl_aura_output_connection(void* data,
                                      struct zaura_output* output,
                                      uint32_t connection) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(zaura_output_get_user_data(output));

  host->internal = connection == ZAURA_OUTPUT_CONNECTION_TYPE_INTERNAL;
}

static void sl_aura_output_device_scale_factor(void* data,
                                               struct zaura_output* output,
                                               uint32_t device_scale_factor) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(zaura_output_get_user_data(output));

  host->device_scale_factor = device_scale_factor;
}

static const struct zaura_output_listener sl_aura_output_listener = {
    sl_aura_output_scale, sl_aura_output_connection,
    sl_aura_output_device_scale_factor, /*insets=*/DoNothing,
    /*logical_transform=*/DoNothing};

static void sl_destroy_host_output(struct wl_resource* resource) {
  struct sl_host_output* host =
      static_cast<sl_host_output*>(wl_resource_get_user_data(resource));

  if (host->aura_output)
    zaura_output_destroy(host->aura_output);
  if (wl_output_get_version(host->proxy) >= WL_OUTPUT_RELEASE_SINCE_VERSION) {
    wl_output_release(host->proxy);
  } else {
    wl_output_destroy(host->proxy);
  }
  wl_resource_set_user_data(resource, nullptr);
  auto pointer = std::find(host->ctx->host_outputs.begin(),
                           host->ctx->host_outputs.end(), host);
  assert(pointer != host->ctx->host_outputs.end());
  host->ctx->host_outputs.erase(pointer);
  free(host->make);
  free(host->model);
  // Shift all outputs to the right of the deleted output to the left.
  sl_output_update_output_x(host->ctx);
  delete host;
}

static void sl_xdg_output_logical_position(
    void* data, struct zxdg_output_v1* zxdg_output_v1, int32_t x, int32_t y) {
  struct sl_host_output* host = static_cast<sl_host_output*>(
      zxdg_output_v1_get_user_data(zxdg_output_v1));
  host->logical_y = y;
  host->logical_x = x;
}

static void sl_xdg_output_logical_size(void* data,
                                       struct zxdg_output_v1* zxdg_output_v1,
                                       int32_t width,
                                       int32_t height) {
  struct sl_host_output* host = static_cast<sl_host_output*>(
      zxdg_output_v1_get_user_data(zxdg_output_v1));

  host->logical_width = width;
  host->logical_height = height;

  host->expecting_logical_size = false;
}

static const struct zxdg_output_v1_listener sl_xdg_output_listener = {
    sl_xdg_output_logical_position, sl_xdg_output_logical_size,
    /*done=*/DoNothing,
    /*name=*/DoNothing, /*desc=*/DoNothing};

static void sl_bind_host_output(struct wl_client* client,
                                void* data,
                                uint32_t version,
                                uint32_t id) {
  struct sl_output* output = (struct sl_output*)data;
  struct sl_context* ctx = output->ctx;
  struct sl_host_output* host = new sl_host_output();
  host->ctx = ctx;
  host->resource = wl_resource_create(client, &wl_output_interface,
                                      MIN(version, output->version), id);
  wl_resource_set_implementation(host->resource, nullptr, host,
                                 sl_destroy_host_output);
  host->proxy = static_cast<wl_output*>(wl_registry_bind(
      wl_display_get_registry(ctx->display), output->id, &wl_output_interface,
      wl_resource_get_version(host->resource)));
  wl_output_add_listener(host->proxy, &sl_output_listener, host);
  output->host_output = host;
  host->aura_output = nullptr;
  // We assume that first output is internal by default.
  host->internal = ctx->host_outputs.empty();
  // We'll always need to forward this information.
  host->needs_update = true;
  host->x = 0;
  host->y = 0;
  host->virt_x = 0;
  host->virt_y = 0;
  host->logical_x = 0;
  host->logical_y = 0;
  host->physical_width = 0;
  host->physical_height = 0;
  host->virt_physical_width = 0;
  host->virt_physical_height = 0;
  host->subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
  host->make = strdup("unknown");
  host->model = strdup("unknown");
  host->transform = WL_OUTPUT_TRANSFORM_NORMAL;
  host->flags = 0;
  host->width = 1024;
  host->height = 768;
  host->virt_width = 1024;
  host->virt_height = 768;
  host->virt_rotated_width = 0;
  host->virt_rotated_height = 0;
  host->logical_width = 1024;
  host->logical_height = 768;
  host->refresh = 60000;
  host->scale_factor = 1;
  host->current_scale = 1000;
  host->preferred_scale = 1000;
  host->device_scale_factor = 1000;
  host->expecting_scale = 0;
  host->expecting_logical_size = false;
  ctx->host_outputs.push_back(host);
  if (ctx->aura_shell) {
    host->expecting_scale = 1;
    host->internal = 0;
    host->aura_output =
        zaura_shell_get_aura_output(ctx->aura_shell->internal, host->proxy);
    zaura_output_add_listener(host->aura_output, &sl_aura_output_listener,
                              host);
  }

  if (ctx->xdg_output_manager) {
    host->expecting_logical_size = true;
    host->zxdg_output = zxdg_output_manager_v1_get_xdg_output(
        ctx->xdg_output_manager->internal, host->proxy);
    zxdg_output_v1_add_listener(host->zxdg_output, &sl_xdg_output_listener,
                                host);
  }
}

struct sl_global* sl_output_global_create(struct sl_output* output) {
  return sl_global_create(output->ctx, &wl_output_interface, output->version,
                          output, sl_bind_host_output);
}