1 files changed, 584 insertions, 335 deletions

diff --git a/sway/config/output.c b/sway/config/output.c
index aa4cf946..fb1956df 100644
--- a/sway/config/output.c
+++ b/sway/config/output.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <drm_fourcc.h>
 #include <stdbool.h>
@@ -6,10 +5,11 @@
 #include <sys/socket.h>
 #include <sys/wait.h>
 #include <unistd.h>
+#include <wlr/config.h>
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_output.h>
-#include <wlr/backend/drm.h>
+#include <wlr/types/wlr_output_swapchain_manager.h>
 #include "sway/config.h"
 #include "sway/input/cursor.h"
 #include "sway/output.h"
@@ -17,6 +17,10 @@
 #include "log.h"
 #include "util.h"
 
+#if WLR_HAS_DRM_BACKEND
+#include <wlr/backend/drm.h>
+#endif
+
 int output_name_cmp(const void *item, const void *data) {
         const struct output_config *output = item;
         const char *name = data;
@@ -71,10 +75,76 @@ struct output_config *new_output_config(const char *name) {
         oc->max_render_time = -1;
         oc->adaptive_sync = -1;
         oc->render_bit_depth = RENDER_BIT_DEPTH_DEFAULT;
+        oc->power = -1;
         return oc;
 }
 
-void merge_output_config(struct output_config *dst, struct output_config *src) {
+// supersede_output_config clears all fields in dst that were set in src
+static void supersede_output_config(struct output_config *dst, struct output_config *src) {
+        if (src->enabled != -1) {
+                dst->enabled = -1;
+        }
+        if (src->width != -1) {
+                dst->width = -1;
+        }
+        if (src->height != -1) {
+                dst->height = -1;
+        }
+        if (src->x != -1) {
+                dst->x = -1;
+        }
+        if (src->y != -1) {
+                dst->y = -1;
+        }
+        if (src->scale != -1) {
+                dst->scale = -1;
+        }
+        if (src->scale_filter != SCALE_FILTER_DEFAULT) {
+                dst->scale_filter = SCALE_FILTER_DEFAULT;
+        }
+        if (src->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN) {
+                dst->subpixel = WL_OUTPUT_SUBPIXEL_UNKNOWN;
+        }
+        if (src->refresh_rate != -1) {
+                dst->refresh_rate = -1;
+        }
+        if (src->custom_mode != -1) {
+                dst->custom_mode = -1;
+        }
+        if (src->drm_mode.type != (uint32_t) -1) {
+                dst->drm_mode.type = -1;
+        }
+        if (src->transform != -1) {
+                dst->transform = -1;
+        }
+        if (src->max_render_time != -1) {
+                dst->max_render_time = -1;
+        }
+        if (src->adaptive_sync != -1) {
+                dst->adaptive_sync = -1;
+        }
+        if (src->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
+                dst->render_bit_depth = RENDER_BIT_DEPTH_DEFAULT;
+        }
+        if (src->background) {
+                free(dst->background);
+                dst->background = NULL;
+        }
+        if (src->background_option) {
+                free(dst->background_option);
+                dst->background_option = NULL;
+        }
+        if (src->background_fallback) {
+                free(dst->background_fallback);
+                dst->background_fallback = NULL;
+        }
+        if (src->power != -1) {
+                dst->power = -1;
+        }
+}
+
+// merge_output_config sets all fields in dst that were set in src
+static void merge_output_config(struct output_config *dst, struct output_config *src) {
         if (src->enabled != -1) {
                 dst->enabled = src->enabled;
         }
@@ -132,158 +202,112 @@ void merge_output_config(struct output_config *dst, struct output_config *src) {
                 free(dst->background_fallback);
                 dst->background_fallback = strdup(src->background_fallback);
         }
-        if (src->dpms_state != 0) {
-                dst->dpms_state = src->dpms_state;
+        if (src->power != -1) {
+                dst->power = src->power;
         }
 }
 
-static void merge_wildcard_on_all(struct output_config *wildcard) {
-        for (int i = 0; i < config->output_configs->length; i++) {
-                struct output_config *oc = config->output_configs->items[i];
-                if (strcmp(wildcard->name, oc->name) != 0) {
-                        sway_log(SWAY_DEBUG, "Merging output * config on %s", oc->name);
-                        merge_output_config(oc, wildcard);
-                }
-        }
-}
+void store_output_config(struct output_config *oc) {
+        bool merged = false;
+        bool wildcard = strcmp(oc->name, "*") == 0;
+        struct sway_output *output = wildcard ? NULL : all_output_by_name_or_id(oc->name);
 
-static void merge_id_on_name(struct output_config *oc) {
-        char *id_on_name = NULL;
         char id[128];
-        char *name = NULL;
-        struct sway_output *output;
-        wl_list_for_each(output, &root->all_outputs, link) {
-                name = output->wlr_output->name;
+        if (output) {
                 output_get_identifier(id, sizeof(id), output);
-                if (strcmp(name, oc->name) == 0 || strcmp(id, oc->name) == 0) {
-                        size_t length = snprintf(NULL, 0, "%s on %s", id, name) + 1;
-                        id_on_name = malloc(length);
-                        if (!id_on_name) {
-                                sway_log(SWAY_ERROR, "Failed to allocate id on name string");
-                                return;
-                        }
-                        snprintf(id_on_name, length, "%s on %s", id, name);
-                        break;
-                }
-        }
-
-        if (!id_on_name) {
-                return;
         }
 
-        int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
-        if (i >= 0) {
-                sway_log(SWAY_DEBUG, "Merging on top of existing id on name config");
-                merge_output_config(config->output_configs->items[i], oc);
-        } else {
-                // If both a name and identifier config, exist generate an id on name
-                int ni = list_seq_find(config->output_configs, output_name_cmp, name);
-                int ii = list_seq_find(config->output_configs, output_name_cmp, id);
-                if ((ni >= 0 && ii >= 0) || (ni >= 0 && strcmp(oc->name, id) == 0)
-                                || (ii >= 0 && strcmp(oc->name, name) == 0)) {
-                        struct output_config *ion_oc = new_output_config(id_on_name);
-                        if (ni >= 0) {
-                                merge_output_config(ion_oc, config->output_configs->items[ni]);
-                        }
-                        if (ii >= 0) {
-                                merge_output_config(ion_oc, config->output_configs->items[ii]);
-                        }
-                        merge_output_config(ion_oc, oc);
-                        list_add(config->output_configs, ion_oc);
-                        sway_log(SWAY_DEBUG, "Generated id on name output config \"%s\""
-                                " (enabled: %d) (%dx%d@%fHz position %d,%d scale %f "
-                                "transform %d) (bg %s %s) (dpms %d) (max render time: %d)",
-                                ion_oc->name, ion_oc->enabled, ion_oc->width, ion_oc->height,
-                                ion_oc->refresh_rate, ion_oc->x, ion_oc->y, ion_oc->scale,
-                                ion_oc->transform, ion_oc->background,
-                                ion_oc->background_option, ion_oc->dpms_state,
-                                ion_oc->max_render_time);
+        for (int i = 0; i < config->output_configs->length; i++) {
+                struct output_config *old = config->output_configs->items[i];
+
+                // If the old config matches the new config's name, regardless of
+                // whether it was name or identifier, merge on top of the existing
+                // config. If the new config is a wildcard, this also merges on top of
+                // old wildcard configs.
+                if (strcmp(old->name, oc->name) == 0) {
+                        merge_output_config(old, oc);
+                        merged = true;
+                        continue;
                 }
-        }
-        free(id_on_name);
-}
 
-struct output_config *store_output_config(struct output_config *oc) {
-        bool wildcard = strcmp(oc->name, "*") == 0;
-        if (wildcard) {
-                merge_wildcard_on_all(oc);
-        } else {
-                merge_id_on_name(oc);
-        }
+                // If the new config is a wildcard config we supersede all non-wildcard
+                // configs. Old wildcard configs have already been handled above.
+                if (wildcard) {
+                        supersede_output_config(old, oc);
+                        continue;
+                }
 
-        int i = list_seq_find(config->output_configs, output_name_cmp, oc->name);
-        if (i >= 0) {
-                sway_log(SWAY_DEBUG, "Merging on top of existing output config");
-                struct output_config *current = config->output_configs->items[i];
-                merge_output_config(current, oc);
-                free_output_config(oc);
-                oc = current;
-        } else if (!wildcard) {
-                sway_log(SWAY_DEBUG, "Adding non-wildcard output config");
-                i = list_seq_find(config->output_configs, output_name_cmp, "*");
-                if (i >= 0) {
-                        sway_log(SWAY_DEBUG, "Merging on top of output * config");
-                        struct output_config *current = new_output_config(oc->name);
-                        merge_output_config(current, config->output_configs->items[i]);
-                        merge_output_config(current, oc);
-                        free_output_config(oc);
-                        oc = current;
+                // If the new config matches an output's name, and the old config
+                // matches on that output's identifier, supersede it.
+                if (output && strcmp(old->name, id) == 0 &&
+                                strcmp(oc->name, output->wlr_output->name) == 0) {
+                        supersede_output_config(old, oc);
                 }
-                list_add(config->output_configs, oc);
-        } else {
-                // New wildcard config. Just add it
-                sway_log(SWAY_DEBUG, "Adding output * config");
-                list_add(config->output_configs, oc);
         }
 
         sway_log(SWAY_DEBUG, "Config stored for output %s (enabled: %d) (%dx%d@%fHz "
-                "position %d,%d scale %f subpixel %s transform %d) (bg %s %s) (dpms %d) "
+                "position %d,%d scale %f subpixel %s transform %d) (bg %s %s) (power %d) "
                 "(max render time: %d)",
                 oc->name, oc->enabled, oc->width, oc->height, oc->refresh_rate,
                 oc->x, oc->y, oc->scale, sway_wl_output_subpixel_to_string(oc->subpixel),
-                oc->transform, oc->background, oc->background_option, oc->dpms_state,
+                oc->transform, oc->background, oc->background_option, oc->power,
                 oc->max_render_time);
 
-        return oc;
+        // If the configuration was not merged into an existing configuration, add
+        // it to the list. Otherwise we're done with it and can free it.
+        if (!merged) {
+                list_add(config->output_configs, oc);
+        } else {
+                free_output_config(oc);
+        }
 }
 
-static void set_mode(struct wlr_output *output, int width, int height,
-                float refresh_rate, bool custom) {
+static void set_mode(struct wlr_output *output, struct wlr_output_state *pending,
+                int width, int height, float refresh_rate, bool custom) {
         // Not all floating point integers can be represented exactly
         // as (int)(1000 * mHz / 1000.f)
         // round() the result to avoid any error
-        int mhz = (int)round(refresh_rate * 1000);
+        int mhz = (int)roundf(refresh_rate * 1000);
+        // If no target refresh rate is given, match highest available
+        mhz = mhz <= 0 ? INT_MAX : mhz;
 
         if (wl_list_empty(&output->modes) || custom) {
                 sway_log(SWAY_DEBUG, "Assigning custom mode to %s", output->name);
-                wlr_output_set_custom_mode(output, width, height,
+                wlr_output_state_set_custom_mode(pending, width, height,
                         refresh_rate > 0 ? mhz : 0);
                 return;
         }
 
         struct wlr_output_mode *mode, *best = NULL;
+        int best_diff_mhz = INT_MAX;
         wl_list_for_each(mode, &output->modes, link) {
                 if (mode->width == width && mode->height == height) {
-                        if (mode->refresh == mhz) {
-                                best = mode;
-                                break;
-                        }
-                        if (best == NULL || mode->refresh > best->refresh) {
+                        int diff_mhz = abs(mode->refresh - mhz);
+                        if (diff_mhz < best_diff_mhz) {
+                                best_diff_mhz = diff_mhz;
                                 best = mode;
+                                if (best_diff_mhz == 0) {
+                                        break;
+                                }
                         }
                 }
         }
-        if (!best) {
-                sway_log(SWAY_ERROR, "Configured mode for %s not available", output->name);
-                sway_log(SWAY_INFO, "Picking preferred mode instead");
-                best = wlr_output_preferred_mode(output);
+        if (best) {
+                sway_log(SWAY_INFO, "Assigning configured mode (%dx%d@%.3fHz) to %s",
+                        best->width, best->height, best->refresh / 1000.f, output->name);
         } else {
-                sway_log(SWAY_DEBUG, "Assigning configured mode to %s", output->name);
+                best = wlr_output_preferred_mode(output);
+                sway_log(SWAY_INFO, "Configured mode (%dx%d@%.3fHz) not available, "
+                        "applying preferred mode (%dx%d@%.3fHz)",
+                        width, height, refresh_rate,
+                        best->width, best->height, best->refresh / 1000.f);
         }
-        wlr_output_set_mode(output, best);
+        wlr_output_state_set_mode(pending, best);
 }
 
-static void set_modeline(struct wlr_output *output, drmModeModeInfo *drm_mode) {
+static void set_modeline(struct wlr_output *output,
+                struct wlr_output_state *pending, drmModeModeInfo *drm_mode) {
+#if WLR_HAS_DRM_BACKEND
         if (!wlr_output_is_drm(output)) {
                 sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
                 return;
@@ -291,8 +315,11 @@ static void set_modeline(struct wlr_output *output, drmModeModeInfo *drm_mode) {
         sway_log(SWAY_DEBUG, "Assigning custom modeline to %s", output->name);
         struct wlr_output_mode *mode = wlr_drm_connector_add_mode(output, drm_mode);
         if (mode) {
-                wlr_output_set_mode(output, mode);
+                wlr_output_state_set_mode(pending, mode);
         }
+#else
+        sway_log(SWAY_ERROR, "Modeline can only be set to DRM output");
+#endif
 }
 
 /* Some manufacturers hardcode the aspect-ratio of the output in the physical
@@ -313,23 +340,24 @@ static bool phys_size_is_aspect_ratio(struct wlr_output *output) {
 // 1 inch = 25.4 mm
 #define MM_PER_INCH 25.4
 
-static int compute_default_scale(struct wlr_output *output) {
+static int compute_default_scale(struct wlr_output *output,
+                struct wlr_output_state *pending) {
         struct wlr_box box = { .width = output->width, .height = output->height };
-        if (output->pending.committed & WLR_OUTPUT_STATE_MODE) {
-                switch (output->pending.mode_type) {
+        if (pending->committed & WLR_OUTPUT_STATE_MODE) {
+                switch (pending->mode_type) {
                 case WLR_OUTPUT_STATE_MODE_FIXED:
-                        box.width = output->pending.mode->width;
-                        box.height = output->pending.mode->height;
+                        box.width = pending->mode->width;
+                        box.height = pending->mode->height;
                         break;
                 case WLR_OUTPUT_STATE_MODE_CUSTOM:
-                        box.width = output->pending.custom_mode.width;
-                        box.height = output->pending.custom_mode.height;
+                        box.width = pending->custom_mode.width;
+                        box.height = pending->custom_mode.height;
                         break;
                 }
         }
         enum wl_output_transform transform = output->transform;
-        if (output->pending.committed & WLR_OUTPUT_STATE_TRANSFORM) {
-                transform = output->pending.transform;
+        if (pending->committed & WLR_OUTPUT_STATE_TRANSFORM) {
+                transform = pending->transform;
         }
         wlr_box_transform(&box, &box, transform, box.width, box.height);
 
@@ -358,88 +386,70 @@ static int compute_default_scale(struct wlr_output *output) {
         return 2;
 }
 
-/* Lists of formats to try, in order, when a specific render bit depth has
- * been asked for. The second to last format in each list should always
- * be XRGB8888, as a reliable backup in case the others are not available;
- * the last should be DRM_FORMAT_INVALID, to indicate the end of the list. */
-static const uint32_t *bit_depth_preferences[] = {
-        [RENDER_BIT_DEPTH_8] = (const uint32_t []){
-                DRM_FORMAT_XRGB8888,
-                DRM_FORMAT_INVALID,
-        },
-        [RENDER_BIT_DEPTH_10] = (const uint32_t []){
-                DRM_FORMAT_XRGB2101010,
-                DRM_FORMAT_XBGR2101010,
-                DRM_FORMAT_XRGB8888,
-                DRM_FORMAT_INVALID,
-        },
-};
+static bool render_format_is_10bit(uint32_t render_format) {
+        return render_format == DRM_FORMAT_XRGB2101010 ||
+                render_format == DRM_FORMAT_XBGR2101010;
+}
+
+static bool render_format_is_bgr(uint32_t fmt) {
+        return fmt == DRM_FORMAT_XBGR2101010 || fmt == DRM_FORMAT_XBGR8888;
+}
+
+static bool output_config_is_disabling(struct output_config *oc) {
+        return oc && (!oc->enabled || oc->power == 0);
+}
 
 static void queue_output_config(struct output_config *oc,
-                struct sway_output *output) {
+                struct sway_output *output, struct wlr_output_state *pending) {
         if (output == root->fallback_output) {
                 return;
         }
 
         struct wlr_output *wlr_output = output->wlr_output;
 
-        if (oc && (!oc->enabled || oc->dpms_state == DPMS_OFF)) {
+        if (output_config_is_disabling(oc)) {
                 sway_log(SWAY_DEBUG, "Turning off output %s", wlr_output->name);
-                wlr_output_enable(wlr_output, false);
+                wlr_output_state_set_enabled(pending, false);
                 return;
         }
 
         sway_log(SWAY_DEBUG, "Turning on output %s", wlr_output->name);
-        wlr_output_enable(wlr_output, true);
+        wlr_output_state_set_enabled(pending, true);
 
         if (oc && oc->drm_mode.type != 0 && oc->drm_mode.type != (uint32_t) -1) {
                 sway_log(SWAY_DEBUG, "Set %s modeline",
                         wlr_output->name);
-                set_modeline(wlr_output, &oc->drm_mode);
+                set_modeline(wlr_output, pending, &oc->drm_mode);
         } else if (oc && oc->width > 0 && oc->height > 0) {
                 sway_log(SWAY_DEBUG, "Set %s mode to %dx%d (%f Hz)",
                         wlr_output->name, oc->width, oc->height, oc->refresh_rate);
-                set_mode(wlr_output, oc->width, oc->height,
+                set_mode(wlr_output, pending, oc->width, oc->height,
                         oc->refresh_rate, oc->custom_mode == 1);
         } else if (!wl_list_empty(&wlr_output->modes)) {
                 sway_log(SWAY_DEBUG, "Set preferred mode");
                 struct wlr_output_mode *preferred_mode =
                         wlr_output_preferred_mode(wlr_output);
-                wlr_output_set_mode(wlr_output, preferred_mode);
-
-                if (!wlr_output_test(wlr_output)) {
-                        sway_log(SWAY_DEBUG, "Preferred mode rejected, "
-                                "falling back to another mode");
-                        struct wlr_output_mode *mode;
-                        wl_list_for_each(mode, &wlr_output->modes, link) {
-                                if (mode == preferred_mode) {
-                                        continue;
-                                }
-
-                                wlr_output_set_mode(wlr_output, mode);
-                                if (wlr_output_test(wlr_output)) {
-                                        break;
-                                }
-                        }
-                }
+                wlr_output_state_set_mode(pending, preferred_mode);
         }
 
         if (oc && (oc->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN || config->reloading)) {
                 sway_log(SWAY_DEBUG, "Set %s subpixel to %s", oc->name,
                         sway_wl_output_subpixel_to_string(oc->subpixel));
-                wlr_output_set_subpixel(wlr_output, oc->subpixel);
+                wlr_output_state_set_subpixel(pending, oc->subpixel);
         }
 
         enum wl_output_transform tr = WL_OUTPUT_TRANSFORM_NORMAL;
         if (oc && oc->transform >= 0) {
                 tr = oc->transform;
+#if WLR_HAS_DRM_BACKEND
         } else if (wlr_output_is_drm(wlr_output)) {
                 tr = wlr_drm_connector_get_panel_orientation(wlr_output);
                 sway_log(SWAY_DEBUG, "Auto-detected output transform: %d", tr);
+#endif
         }
         if (wlr_output->transform != tr) {
                 sway_log(SWAY_DEBUG, "Set %s transform to %d", oc->name, tr);
-                wlr_output_set_transform(wlr_output, tr);
+                wlr_output_state_set_transform(pending, tr);
         }
 
         // Apply the scale last before the commit, because the scale auto-detection
@@ -447,66 +457,50 @@ static void queue_output_config(struct output_config *oc,
         float scale;
         if (oc && oc->scale > 0) {
                 scale = oc->scale;
+
+                // The factional-scale-v1 protocol uses increments of 120ths to send
+                // the scale factor to the client. Adjust the scale so that we use the
+                // same value as the clients'.
+                float adjusted_scale = round(scale * 120) / 120;
+                if (scale != adjusted_scale) {
+                        sway_log(SWAY_INFO, "Adjusting output scale from %f to %f",
+                                scale, adjusted_scale);
+                        scale = adjusted_scale;
+                }
         } else {
-                scale = compute_default_scale(wlr_output);
+                scale = compute_default_scale(wlr_output, pending);
                 sway_log(SWAY_DEBUG, "Auto-detected output scale: %f", scale);
         }
         if (scale != wlr_output->scale) {
                 sway_log(SWAY_DEBUG, "Set %s scale to %f", wlr_output->name, scale);
-                wlr_output_set_scale(wlr_output, scale);
+                wlr_output_state_set_scale(pending, scale);
         }
 
         if (oc && oc->adaptive_sync != -1) {
                 sway_log(SWAY_DEBUG, "Set %s adaptive sync to %d", wlr_output->name,
                         oc->adaptive_sync);
-                wlr_output_enable_adaptive_sync(wlr_output, oc->adaptive_sync == 1);
+                wlr_output_state_set_adaptive_sync_enabled(pending, oc->adaptive_sync == 1);
         }
 
         if (oc && oc->render_bit_depth != RENDER_BIT_DEPTH_DEFAULT) {
-                const uint32_t *fmts = bit_depth_preferences[oc->render_bit_depth];
-                assert(fmts);
-
-                for (size_t i = 0; fmts[i] != DRM_FORMAT_INVALID; i++) {
-                        wlr_output_set_render_format(wlr_output, fmts[i]);
-                        if (wlr_output_test(wlr_output)) {
-                                break;
-                        }
-
-                        sway_log(SWAY_DEBUG, "Preferred output format 0x%08x "
-                                "failed to work, falling back to next in "
-                                "list, 0x%08x", fmts[i], fmts[i + 1]);
+                if (oc->render_bit_depth == RENDER_BIT_DEPTH_10 &&
+                        render_format_is_10bit(output->wlr_output->render_format)) {
+                        // 10-bit was set successfully before, try to save some tests by reusing the format
+                        wlr_output_state_set_render_format(pending, output->wlr_output->render_format);
+                } else if (oc->render_bit_depth == RENDER_BIT_DEPTH_10) {
+                        wlr_output_state_set_render_format(pending, DRM_FORMAT_XRGB2101010);
+                } else {
+                        wlr_output_state_set_render_format(pending, DRM_FORMAT_XRGB8888);
                 }
         }
 }
 
-bool apply_output_config(struct output_config *oc, struct sway_output *output) {
+static bool finalize_output_config(struct output_config *oc, struct sway_output *output) {
         if (output == root->fallback_output) {
                 return false;
         }
 
         struct wlr_output *wlr_output = output->wlr_output;
-
-        // Flag to prevent the output mode event handler from calling us
-        output->enabling = (!oc || oc->enabled);
-
-        queue_output_config(oc, output);
-
-        if (!oc || oc->dpms_state != DPMS_OFF) {
-                output->current_mode = wlr_output->pending.mode;
-        }
-
-        sway_log(SWAY_DEBUG, "Committing output %s", wlr_output->name);
-        if (!wlr_output_commit(wlr_output)) {
-                // Failed to commit output changes, maybe the output is missing a CRTC.
-                // Leave the output disabled for now and try again when the output gets
-                // the mode we asked for.
-                sway_log(SWAY_ERROR, "Failed to commit output %s", wlr_output->name);
-                output->enabling = false;
-                return false;
-        }
-
-        output->enabling = false;
-
         if (oc && !oc->enabled) {
                 sway_log(SWAY_DEBUG, "Disabling output %s", oc->name);
                 if (output->enabled) {
@@ -516,10 +510,6 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                 return true;
         }
 
-        if (config->reloading) {
-                output_damage_whole(output);
-        }
-
         if (oc) {
                 enum scale_filter_mode scale_filter_old = output->scale_filter;
                 switch (oc->scale_filter) {
@@ -536,6 +526,7 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                 if (scale_filter_old != output->scale_filter) {
                         sway_log(SWAY_DEBUG, "Set %s scale_filter to %s", oc->name,
                                 sway_output_scale_filter_to_string(output->scale_filter));
+                        wlr_damage_ring_add_whole(&output->scene_output->damage_ring);
                 }
         }
 
@@ -565,29 +556,13 @@ bool apply_output_config(struct output_config *oc, struct sway_output *output) {
                 output->max_render_time = oc->max_render_time;
         }
 
-        // Reconfigure all devices, since input config may have been applied before
-        // this output came online, and some config items (like map_to_output) are
-        // dependent on an output being present.
-        input_manager_configure_all_inputs();
-        // Reconfigure the cursor images, since the scale may have changed.
-        input_manager_configure_xcursor();
         return true;
 }
 
-bool test_output_config(struct output_config *oc, struct sway_output *output) {
-        if (output == root->fallback_output) {
-                return false;
-        }
-
-        queue_output_config(oc, output);
-        bool ok = wlr_output_test(output->wlr_output);
-        wlr_output_rollback(output->wlr_output);
-        return ok;
-}
-
 static void default_output_config(struct output_config *oc,
                 struct wlr_output *wlr_output) {
         oc->enabled = 1;
+        oc->power = 1;
         struct wlr_output_mode *mode = wlr_output_preferred_mode(wlr_output);
         if (mode != NULL) {
                 oc->width = mode->width;
@@ -600,147 +575,418 @@ static void default_output_config(struct output_config *oc,
         struct sway_output *output = wlr_output->data;
         oc->subpixel = output->detected_subpixel;
         oc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
-        oc->dpms_state = DPMS_ON;
         oc->max_render_time = 0;
 }
 
-static struct output_config *get_output_config(char *identifier,
-                struct sway_output *sway_output) {
+// find_output_config returns a merged output_config containing all stored
+// configuration that applies to the specified output.
+struct output_config *find_output_config(struct sway_output *sway_output) {
         const char *name = sway_output->wlr_output->name;
+        struct output_config *oc = NULL;
 
-        struct output_config *oc_id_on_name = NULL;
-        struct output_config *oc_name = NULL;
-        struct output_config *oc_id = NULL;
+        struct output_config *result = new_output_config(name);
+        if (config->reloading) {
+                default_output_config(result, sway_output->wlr_output);
+        }
 
-        size_t length = snprintf(NULL, 0, "%s on %s", identifier, name) + 1;
-        char *id_on_name = malloc(length);
-        snprintf(id_on_name, length, "%s on %s", identifier, name);
-        int i = list_seq_find(config->output_configs, output_name_cmp, id_on_name);
-        if (i >= 0) {
-                oc_id_on_name = config->output_configs->items[i];
-        } else {
-                i = list_seq_find(config->output_configs, output_name_cmp, name);
-                if (i >= 0) {
-                        oc_name = config->output_configs->items[i];
+        char id[128];
+        output_get_identifier(id, sizeof(id), sway_output);
+
+        int i;
+        bool match = false;
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, "*")) >= 0) {
+                match = true;
+                oc = config->output_configs->items[i];
+                merge_output_config(result, oc);
+        }
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, name)) >= 0) {
+                match = true;
+                oc = config->output_configs->items[i];
+                merge_output_config(result, oc);
+        }
+        if ((i = list_seq_find(config->output_configs, output_name_cmp, id)) >= 0) {
+                match = true;
+                oc = config->output_configs->items[i];
+                merge_output_config(result, oc);
+        }
+
+        if (!match && !config->reloading) {
+                // No name, identifier, or wildcard config. Since we are not
+                // reloading with defaults, the output config will be empty, so
+                // just return NULL
+                free_output_config(result);
+                return NULL;
+        }
+
+        return result;
+}
+
+static bool config_has_auto_mode(struct output_config *oc) {
+        if (!oc) {
+                return true;
+        }
+        if (oc->drm_mode.type != 0 && oc->drm_mode.type != (uint32_t)-1) {
+                return true;
+        } else if (oc->width > 0 && oc->height > 0) {
+                return true;
+        }
+        return false;
+}
+
+struct search_context {
+        struct wlr_output_swapchain_manager *swapchain_mgr;
+        struct wlr_backend_output_state *states;
+        struct matched_output_config *configs;
+        size_t configs_len;
+        bool degrade_to_off;
+};
+
+static void dump_output_state(struct wlr_output *wlr_output, struct wlr_output_state *state) {
+        sway_log(SWAY_DEBUG, "Output state for %s", wlr_output->name);
+        if (state->committed & WLR_OUTPUT_STATE_ENABLED) {
+                sway_log(SWAY_DEBUG, "    enabled:       %s", state->enabled ? "yes" : "no");
+        }
+        if (state->committed & WLR_OUTPUT_STATE_RENDER_FORMAT) {
+                sway_log(SWAY_DEBUG, "    render_format: %d", state->render_format);
+        }
+        if (state->committed & WLR_OUTPUT_STATE_MODE) {
+                if (state->mode_type == WLR_OUTPUT_STATE_MODE_CUSTOM) {
+                        sway_log(SWAY_DEBUG, "    custom mode:   %dx%d@%dmHz",
+                                state->custom_mode.width, state->custom_mode.height, state->custom_mode.refresh);
+                } else {
+                        sway_log(SWAY_DEBUG, "    mode:          %dx%d@%dmHz%s",
+                                state->mode->width, state->mode->height, state->mode->refresh,
+                                state->mode->preferred ? " (preferred)" : "");
+                }
+        }
+        if (state->committed & WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED) {
+                sway_log(SWAY_DEBUG, "    adaptive_sync: %s",
+                        state->adaptive_sync_enabled ? "enabled": "disabled");
+        }
+}
+
+static bool search_valid_config(struct search_context *ctx, size_t output_idx);
+
+static void reset_output_state(struct wlr_output_state *state) {
+        wlr_output_state_finish(state);
+        wlr_output_state_init(state);
+        state->committed = 0;
+}
+
+static void clear_later_output_states(struct wlr_backend_output_state *states,
+                size_t configs_len, size_t output_idx) {
+
+        // Clear and disable all output states after this one to avoid conflict
+        // with previous tests.
+        for (size_t idx = output_idx+1; idx < configs_len; idx++) {
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                struct wlr_output_state *state = &backend_state->base;
+
+                reset_output_state(state);
+                wlr_output_state_set_enabled(state, false);
+        }
+}
+
+static bool search_finish(struct search_context *ctx, size_t output_idx) {
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+
+        clear_later_output_states(ctx->states, ctx->configs_len, output_idx);
+        dump_output_state(wlr_output, state);
+        return wlr_output_swapchain_manager_prepare(ctx->swapchain_mgr, ctx->states, ctx->configs_len) &&
+                search_valid_config(ctx, output_idx+1);
+}
+
+static bool search_adaptive_sync(struct search_context *ctx, size_t output_idx) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+
+        if (cfg->config && cfg->config->adaptive_sync == 1) {
+                wlr_output_state_set_adaptive_sync_enabled(state, true);
+                if (search_finish(ctx, output_idx)) {
+                        return true;
+                }
+        }
+        if (!cfg->config || cfg->config->adaptive_sync != -1) {
+                wlr_output_state_set_adaptive_sync_enabled(state, false);
+                if (search_finish(ctx, output_idx)) {
+                        return true;
                 }
+        }
+        // If adaptive sync has not been set, or fallback in case we are on a
+        // backend that cannot disable adaptive sync such as the wayland backend.
+        state->committed &= ~WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED;
+        return search_finish(ctx, output_idx);
+}
+
+static bool search_mode(struct search_context *ctx, size_t output_idx) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
 
-                i = list_seq_find(config->output_configs, output_name_cmp, identifier);
-                if (i >= 0) {
-                        oc_id = config->output_configs->items[i];
+        if (!config_has_auto_mode(cfg->config)) {
+                return search_adaptive_sync(ctx, output_idx);
+        }
+
+        struct wlr_output_mode *preferred_mode = wlr_output_preferred_mode(wlr_output);
+        if (preferred_mode) {
+                wlr_output_state_set_mode(state, preferred_mode);
+                if (search_adaptive_sync(ctx, output_idx)) {
+                        return true;
                 }
         }
 
-        struct output_config *result = new_output_config("temp");
-        if (config->reloading) {
-                default_output_config(result, sway_output->wlr_output);
+        if (wl_list_empty(&wlr_output->modes)) {
+                state->committed &= ~WLR_OUTPUT_STATE_MODE;
+                return search_adaptive_sync(ctx, output_idx);
         }
-        if (oc_id_on_name) {
-                // Already have an identifier on name config, use that
-                free(result->name);
-                result->name = strdup(id_on_name);
-                merge_output_config(result, oc_id_on_name);
-        } else if (oc_name && oc_id) {
-                // Generate a config named `<identifier> on <name>` which contains a
-                // merged copy of the identifier on name. This will make sure that both
-                // identifier and name configs are respected, with identifier getting
-                // priority
-                struct output_config *temp = new_output_config(id_on_name);
-                merge_output_config(temp, oc_name);
-                merge_output_config(temp, oc_id);
-                list_add(config->output_configs, temp);
-
-                free(result->name);
-                result->name = strdup(id_on_name);
-                merge_output_config(result, temp);
-
-                sway_log(SWAY_DEBUG, "Generated output config \"%s\" (enabled: %d)"
-                        " (%dx%d@%fHz position %d,%d scale %f transform %d) (bg %s %s)"
-                        " (dpms %d) (max render time: %d)", result->name, result->enabled,
-                        result->width, result->height, result->refresh_rate,
-                        result->x, result->y, result->scale, result->transform,
-                        result->background, result->background_option, result->dpms_state,
-                        result->max_render_time);
-        } else if (oc_name) {
-                // No identifier config, just return a copy of the name config
-                free(result->name);
-                result->name = strdup(name);
-                merge_output_config(result, oc_name);
-        } else if (oc_id) {
-                // No name config, just return a copy of the identifier config
-                free(result->name);
-                result->name = strdup(identifier);
-                merge_output_config(result, oc_id);
-        } else {
-                i = list_seq_find(config->output_configs, output_name_cmp, "*");
-                if (i >= 0) {
-                        // No name or identifier config, but there is a wildcard config
-                        free(result->name);
-                        result->name = strdup("*");
-                        merge_output_config(result, config->output_configs->items[i]);
-                } else if (!config->reloading) {
-                        // No name, identifier, or wildcard config. Since we are not
-                        // reloading with defaults, the output config will be empty, so
-                        // just return NULL
-                        free_output_config(result);
-                        result = NULL;
+
+        struct wlr_output_mode *mode;
+        wl_list_for_each(mode, &backend_state->output->modes, link) {
+                if (mode == preferred_mode) {
+                        continue;
+                }
+                wlr_output_state_set_mode(state, mode);
+                if (search_adaptive_sync(ctx, output_idx)) {
+                        return true;
                 }
         }
 
-        free(id_on_name);
-        return result;
+        return false;
 }
 
-struct output_config *find_output_config(struct sway_output *output) {
-        char id[128];
-        output_get_identifier(id, sizeof(id), output);
-        return get_output_config(id, output);
+static bool search_render_format(struct search_context *ctx, size_t output_idx) {
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+
+        uint32_t fmts[] = {
+                DRM_FORMAT_XRGB2101010,
+                DRM_FORMAT_XBGR2101010,
+                DRM_FORMAT_XRGB8888,
+                DRM_FORMAT_INVALID,
+        };
+        if (render_format_is_bgr(wlr_output->render_format)) {
+                // Start with BGR in the unlikely event that we previously required it.
+                fmts[0] = DRM_FORMAT_XBGR2101010;
+                fmts[1] = DRM_FORMAT_XRGB2101010;
+        }
+
+        const struct wlr_drm_format_set *primary_formats =
+                wlr_output_get_primary_formats(wlr_output, WLR_BUFFER_CAP_DMABUF);
+        bool need_10bit = cfg->config && cfg->config->render_bit_depth == RENDER_BIT_DEPTH_10;
+        for (size_t idx = 0; fmts[idx] != DRM_FORMAT_INVALID; idx++) {
+                if (!need_10bit && render_format_is_10bit(fmts[idx])) {
+                        continue;
+                }
+                if (!wlr_drm_format_set_get(primary_formats, fmts[idx])) {
+                        // This is not a supported format for this output
+                        continue;
+                }
+                wlr_output_state_set_render_format(state, fmts[idx]);
+                if (search_mode(ctx, output_idx)) {
+                        return true;
+                }
+        }
+        return false;
 }
 
-void apply_output_config_to_outputs(struct output_config *oc) {
-        // Try to find the output container and apply configuration now. If
-        // this is during startup then there will be no container and config
-        // will be applied during normal "new output" event from wlroots.
-        bool wildcard = strcmp(oc->name, "*") == 0;
-        char id[128];
-        struct sway_output *sway_output, *tmp;
-        wl_list_for_each_safe(sway_output, tmp, &root->all_outputs, link) {
-                char *name = sway_output->wlr_output->name;
-                output_get_identifier(id, sizeof(id), sway_output);
-                if (wildcard || !strcmp(name, oc->name) || !strcmp(id, oc->name)) {
-                        struct output_config *current = get_output_config(id, sway_output);
-                        if (!current) {
-                                // No stored output config matched, apply oc directly
-                                sway_log(SWAY_DEBUG, "Applying oc directly");
-                                current = new_output_config(oc->name);
-                                merge_output_config(current, oc);
-                        }
-                        apply_output_config(current, sway_output);
-                        free_output_config(current);
+static bool search_valid_config(struct search_context *ctx, size_t output_idx) {
+        if (output_idx >= ctx->configs_len) {
+                // We reached the end of the search, all good!
+                return true;
+        }
 
-                        if (!wildcard) {
-                                // Stop looking if the output config isn't applicable to all
-                                // outputs
-                                break;
-                        }
+        struct matched_output_config *cfg = &ctx->configs[output_idx];
+        struct wlr_backend_output_state *backend_state = &ctx->states[output_idx];
+        struct wlr_output_state *state = &backend_state->base;
+        struct wlr_output *wlr_output = backend_state->output;
+
+        if (!output_config_is_disabling(cfg->config)) {
+                // Search through our possible configurations, doing a depth-first
+                // through render_format, modes, adaptive_sync and the next output's
+                // config.
+                queue_output_config(cfg->config, cfg->output, &backend_state->base);
+                if (search_render_format(ctx, output_idx)) {
+                        return true;
+                } else if (!ctx->degrade_to_off) {
+                        return false;
+                }
+                // We could not get anything to work, try to disable this output to see
+                // if we can at least make the outputs before us work.
+                sway_log(SWAY_DEBUG, "Unable to find valid config with output %s, disabling",
+                        wlr_output->name);
+                reset_output_state(state);
+        }
+
+        wlr_output_state_set_enabled(state, false);
+        return search_finish(ctx, output_idx);
+}
+
+static int compare_matched_output_config_priority(const void *a, const void *b) {
+
+        const struct matched_output_config *amc = a;
+        const struct matched_output_config *bmc = b;
+        bool a_disabling = output_config_is_disabling(amc->config);
+        bool b_disabling = output_config_is_disabling(bmc->config);
+        bool a_enabled = amc->output->enabled;
+        bool b_enabled = bmc->output->enabled;
+
+        // We want to give priority to existing enabled outputs. To do so, we want
+        // the configuration order to be:
+        // 1. Existing, enabled outputs
+        // 2. Outputs that need to be enabled
+        // 3. Disabled or disabling outputs
+        if (a_enabled && !a_disabling) {
+                return -1;
+        } else if (b_enabled && !b_disabling) {
+                return 1;
+        } else if (b_disabling && !a_disabling) {
+                return -1;
+        } else if (a_disabling && !b_disabling) {
+                return 1;
+        }
+        return 0;
+}
+
+void sort_output_configs_by_priority(struct matched_output_config *configs,
+                size_t configs_len) {
+        qsort(configs, configs_len, sizeof(*configs), compare_matched_output_config_priority);
+}
+
+bool apply_output_configs(struct matched_output_config *configs,
+                size_t configs_len, bool test_only, bool degrade_to_off) {
+        struct wlr_backend_output_state *states = calloc(configs_len, sizeof(*states));
+        if (!states) {
+                return false;
+        }
+
+        sway_log(SWAY_DEBUG, "Committing %zd outputs", configs_len);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                struct wlr_backend_output_state *backend_state = &states[idx];
+
+                backend_state->output = cfg->output->wlr_output;
+                wlr_output_state_init(&backend_state->base);
+
+                sway_log(SWAY_DEBUG, "Preparing config for %s",
+                        cfg->output->wlr_output->name);
+                queue_output_config(cfg->config, cfg->output, &backend_state->base);
+        }
+
+        struct wlr_output_swapchain_manager swapchain_mgr;
+        wlr_output_swapchain_manager_init(&swapchain_mgr, server.backend);
+
+        bool ok = wlr_output_swapchain_manager_prepare(&swapchain_mgr, states, configs_len);
+        if (!ok) {
+                sway_log(SWAY_ERROR, "Requested backend configuration failed, searching for valid fallbacks");
+                struct search_context ctx = {
+                        .swapchain_mgr = &swapchain_mgr,
+                        .states = states,
+                        .configs = configs,
+                        .configs_len = configs_len,
+                        .degrade_to_off = degrade_to_off,
+                };
+                if (!search_valid_config(&ctx, 0)) {
+                        sway_log(SWAY_ERROR, "Search for valid config failed");
+                        goto out;
                 }
         }
 
+        if (test_only) {
+                // The swapchain manager already did a test for us
+                goto out;
+        }
+
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                struct wlr_backend_output_state *backend_state = &states[idx];
+
+                struct wlr_scene_output_state_options opts = {
+                        .swapchain = wlr_output_swapchain_manager_get_swapchain(
+                                &swapchain_mgr, backend_state->output),
+                };
+                struct wlr_scene_output *scene_output = cfg->output->scene_output;
+                struct wlr_output_state *state = &backend_state->base;
+                if (!wlr_scene_output_build_state(scene_output, state, &opts)) {
+                        sway_log(SWAY_ERROR, "Building output state for '%s' failed",
+                                backend_state->output->name);
+                        goto out;
+                }
+        }
+
+        ok = wlr_backend_commit(server.backend, states, configs_len);
+        if (!ok) {
+                sway_log(SWAY_ERROR, "Backend commit failed");
+                goto out;
+        }
+
+        sway_log(SWAY_DEBUG, "Commit of %zd outputs succeeded", configs_len);
+
+        wlr_output_swapchain_manager_apply(&swapchain_mgr);
+
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                sway_log(SWAY_DEBUG, "Finalizing config for %s",
+                        cfg->output->wlr_output->name);
+                finalize_output_config(cfg->config, cfg->output);
+        }
+
+out:
+        wlr_output_swapchain_manager_finish(&swapchain_mgr);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct wlr_backend_output_state *backend_state = &states[idx];
+                wlr_output_state_finish(&backend_state->base);
+        }
+        free(states);
+
+        // Reconfigure all devices, since input config may have been applied before
+        // this output came online, and some config items (like map_to_output) are
+        // dependent on an output being present.
+        input_manager_configure_all_input_mappings();
+        // Reconfigure the cursor images, since the scale may have changed.
+        input_manager_configure_xcursor();
+
         struct sway_seat *seat;
         wl_list_for_each(seat, &server.input->seats, link) {
                 wlr_seat_pointer_notify_clear_focus(seat->wlr_seat);
                 cursor_rebase(seat->cursor);
         }
+
+        return ok;
 }
 
-void reset_outputs(void) {
-        struct output_config *oc = NULL;
-        int i = list_seq_find(config->output_configs, output_name_cmp, "*");
-        if (i >= 0) {
-                oc = config->output_configs->items[i];
-        } else {
-                oc = store_output_config(new_output_config("*"));
+void apply_all_output_configs(void) {
+        size_t configs_len = wl_list_length(&root->all_outputs);
+        struct matched_output_config *configs = calloc(configs_len, sizeof(*configs));
+        if (!configs) {
+                return;
         }
-        apply_output_config_to_outputs(oc);
+
+        int config_idx = 0;
+        struct sway_output *sway_output;
+        wl_list_for_each(sway_output, &root->all_outputs, link) {
+                if (sway_output == root->fallback_output) {
+                        configs_len--;
+                        continue;
+                }
+
+                struct matched_output_config *config = &configs[config_idx++];
+                config->output = sway_output;
+                config->config = find_output_config(sway_output);
+        }
+
+        sort_output_configs_by_priority(configs, configs_len);
+        apply_output_configs(configs, configs_len, false, true);
+        for (size_t idx = 0; idx < configs_len; idx++) {
+                struct matched_output_config *cfg = &configs[idx];
+                free_output_config(cfg->config);
+        }
+        free(configs);
 }
 
 void free_output_config(struct output_config *oc) {
@@ -807,7 +1053,9 @@ static bool _spawn_swaybg(char **command) {
                         setenv("WAYLAND_SOCKET", wayland_socket_str, true);
 
                         execvp(command[0], command);
-                        sway_log_errno(SWAY_ERROR, "execvp failed");
+                        sway_log_errno(SWAY_ERROR, "failed to execute '%s' "
+                                "(background configuration probably not applied)",
+                                command[0]);
                         _exit(EXIT_FAILURE);
                 }
                 _exit(EXIT_SUCCESS);
@@ -817,12 +1065,13 @@ static bool _spawn_swaybg(char **command) {
                 sway_log_errno(SWAY_ERROR, "close failed");
                 return false;
         }
-        if (waitpid(pid, NULL, 0) < 0) {
+        int fork_status = 0;
+        if (waitpid(pid, &fork_status, 0) < 0) {
                 sway_log_errno(SWAY_ERROR, "waitpid failed");
                 return false;
         }
 
-        return true;
+        return WIFEXITED(fork_status) && WEXITSTATUS(fork_status) == EXIT_SUCCESS;
 }
 
 bool spawn_swaybg(void) {