1 files changed, 507 insertions, 268 deletions

diff --git a/sway/config/output.c b/sway/config/output.c
index 1b2332e9..9a447388 100644
--- a/sway/config/output.c
+++ b/sway/config/output.c
@@ -9,9 +9,11 @@
 #include <wlr/types/wlr_cursor.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_output.h>
+#include <wlr/types/wlr_output_swapchain_manager.h>
 #include "sway/config.h"
 #include "sway/input/cursor.h"
 #include "sway/output.h"
+#include "sway/server.h"
 #include "sway/tree/root.h"
 #include "log.h"
 #include "util.h"
@@ -78,7 +80,72 @@ struct output_config *new_output_config(const char *name) {
         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;
         }
@@ -141,94 +208,42 @@ void merge_output_config(struct output_config *dst, struct output_config *src) {
         }
 }
 
-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);
-                }
-        }
-}
-
-static void merge_id_on_name(struct output_config *oc) {
-        struct sway_output *output = all_output_by_name_or_id(oc->name);
-        if (output == NULL) {
-                return;
-        }
+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);
 
-        const char *name = output->wlr_output->name;
         char id[128];
-        output_get_identifier(id, sizeof(id), output);
-
-        char *id_on_name = format_str("%s on %s", id, name);
-        if (!id_on_name) {
-                return;
+        if (output) {
+                output_get_identifier(id, sizeof(id), output);
         }
 
-        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) (power %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->power,
-                                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 "
@@ -239,7 +254,13 @@ struct output_config *store_output_config(struct output_config *oc) {
                 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, struct wlr_output_state *pending,
@@ -366,22 +387,18 @@ 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 wlr_output_state *pending) {
@@ -391,7 +408,7 @@ static void queue_output_config(struct output_config *oc,
 
         struct wlr_output *wlr_output = output->wlr_output;
 
-        if (oc && (!oc->enabled || oc->power == 0)) {
+        if (output_config_is_disabling(oc)) {
                 sway_log(SWAY_DEBUG, "Turning off output %s", wlr_output->name);
                 wlr_output_state_set_enabled(pending, false);
                 return;
@@ -414,22 +431,6 @@ static void queue_output_config(struct output_config *oc,
                 struct wlr_output_mode *preferred_mode =
                         wlr_output_preferred_mode(wlr_output);
                 wlr_output_state_set_mode(pending, preferred_mode);
-
-                if (!wlr_output_test_state(wlr_output, pending)) {
-                        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_state_set_mode(pending, mode);
-                                if (wlr_output_test_state(wlr_output, pending)) {
-                                        break;
-                                }
-                        }
-                }
         }
 
         if (oc && (oc->subpixel != WL_OUTPUT_SUBPIXEL_UNKNOWN || config->reloading)) {
@@ -448,7 +449,7 @@ static void queue_output_config(struct output_config *oc,
 #endif
         }
         if (wlr_output->transform != tr) {
-                sway_log(SWAY_DEBUG, "Set %s transform to %d", oc->name, tr);
+                sway_log(SWAY_DEBUG, "Set %s transform to %d", wlr_output->name, tr);
                 wlr_output_state_set_transform(pending, tr);
         }
 
@@ -480,48 +481,27 @@ static void queue_output_config(struct output_config *oc,
                 sway_log(SWAY_DEBUG, "Set %s adaptive sync to %d", wlr_output->name,
                         oc->adaptive_sync);
                 wlr_output_state_set_adaptive_sync_enabled(pending, oc->adaptive_sync == 1);
-                if (oc->adaptive_sync == 1 && !wlr_output_test_state(wlr_output, pending)) {
-                        sway_log(SWAY_DEBUG, "Adaptive sync failed, ignoring");
-                        wlr_output_state_set_adaptive_sync_enabled(pending, false);
-                }
         }
 
         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_state_set_render_format(pending, fmts[i]);
-                        if (wlr_output_test_state(wlr_output, pending)) {
-                                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;
-
-        struct wlr_output_state pending = {0};
-        queue_output_config(oc, output, &pending);
-
-        sway_log(SWAY_DEBUG, "Committing output %s", wlr_output->name);
-        if (!wlr_output_commit_state(wlr_output, &pending)) {
-                // 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);
-                return false;
-        }
-
         if (oc && !oc->enabled) {
                 sway_log(SWAY_DEBUG, "Disabling output %s", oc->name);
                 if (output->enabled) {
@@ -577,25 +557,9 @@ 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_input_mappings();
-        // 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;
-        }
-
-        struct wlr_output_state pending = {0};
-        queue_output_config(oc, output, &pending);
-        return wlr_output_test_state(output->wlr_output, &pending);
-}
-
 static void default_output_config(struct output_config *oc,
                 struct wlr_output *wlr_output) {
         oc->enabled = 1;
@@ -615,140 +579,415 @@ static void default_output_config(struct output_config *oc,
         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);
+        }
 
-        char *id_on_name = format_str("%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) {
 
-                i = list_seq_find(config->output_configs, output_name_cmp, identifier);
-                if (i >= 0) {
-                        oc_id = config->output_configs->items[i];
+        // 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);
+}
 
-        struct output_config *result = new_output_config("temp");
-        if (config->reloading) {
-                default_output_config(result, sway_output->wlr_output);
+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;
+
+        if (!config_has_auto_mode(cfg->config)) {
+                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)"
-                        " (power %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->power,
-                        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 *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;
                 }
         }
 
-        free(id_on_name);
-        return result;
+        if (wl_list_empty(&wlr_output->modes)) {
+                state->committed &= ~WLR_OUTPUT_STATE_MODE;
+                return search_adaptive_sync(ctx, output_idx);
+        }
+
+        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;
+                }
+        }
+
+        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;
-        struct sway_output *sway_output, *tmp;
-        wl_list_for_each_safe(sway_output, tmp, &root->all_outputs, link) {
-                if (output_match_name_or_id(sway_output, oc->name)) {
-                        char id[128];
-                        output_get_identifier(id, sizeof(id), sway_output);
-                        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;
+        }
+
+        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);
         }
-        apply_output_config_to_outputs(oc);
+        free(configs);
 }
 
 void free_output_config(struct output_config *oc) {