GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found) { int i; GLFWvidmode* modes = NULL; MirDisplayConfiguration* displayConfig = mir_connection_create_display_config(_glfw.mir.connection); for (i = 0; i < displayConfig->num_outputs; i++) { const MirDisplayOutput* out = displayConfig->outputs + i; if (out->output_id != monitor->mir.output_id) continue; modes = calloc(out->num_modes, sizeof(GLFWvidmode)); for (*found = 0; *found < out->num_modes; (*found)++) { modes[*found].width = out->modes[*found].horizontal_resolution; modes[*found].height = out->modes[*found].vertical_resolution; modes[*found].refreshRate = out->modes[*found].refresh_rate; modes[*found].redBits = 8; modes[*found].greenBits = 8; modes[*found].blueBits = 8; } break; } mir_display_config_destroy(displayConfig); return modes; }
// Poll for changes in the set of connected monitors // void _glfwPollMonitorsMir(void) { int i; MirDisplayConfiguration* displayConfig = mir_connection_create_display_config(_glfw.mir.connection); for (i = 0; i < displayConfig->num_outputs; i++) { const MirDisplayOutput* out = displayConfig->outputs + i; if (out->used && out->connected && out->num_modes && out->current_mode < out->num_modes) { _GLFWmonitor* monitor = _glfwAllocMonitor("Unknown", out->physical_width_mm, out->physical_height_mm); monitor->mir.x = out->position_x; monitor->mir.y = out->position_y; monitor->mir.outputId = out->output_id; monitor->mir.curMode = out->current_mode; monitor->modes = _glfwPlatformGetVideoModes(monitor, &monitor->modeCount); _glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST); } } mir_display_config_destroy(displayConfig); }
MirDisplayConnection::MirDisplayConnection() : connection_(nullptr), output_id_(-1), vertical_resolution_(0), horizontal_resolution_(0) { auto xdg_runtime_dir = ::getenv("XDG_RUNTIME_DIR"); if (!xdg_runtime_dir) BOOST_THROW_EXCEPTION(std::runtime_error("Failed to find XDG_RUNTIME_DIR")); std::string socket_path = xdg_runtime_dir; socket_path += "/mir_socket"; connection_ = mir_connect_sync(socket_path.c_str(), "anbox"); if (!mir_connection_is_valid(connection_)) { std::string msg; msg += "Failed to connect with Mir server: "; msg += mir_connection_get_error_message(connection_); BOOST_THROW_EXCEPTION(std::runtime_error(msg.c_str())); } mir_connection_set_display_config_change_callback( connection_, [](MirConnection *connection, void *context) { auto thiz = reinterpret_cast<MirDisplayConnection *>(context); DEBUG(""); }, this); MirDisplayConfiguration *display_config = mir_connection_create_display_config(connection_); const MirDisplayOutput *output = find_active_output(display_config); if (!output) BOOST_THROW_EXCEPTION( std::runtime_error("Failed to find active output display")); DEBUG("Selecting output id %d", output->output_id); output_id_ = output->output_id; const MirDisplayMode *mode = &output->modes[output->current_mode]; vertical_resolution_ = mode->vertical_resolution; horizontal_resolution_ = mode->horizontal_resolution; mir_display_config_destroy(display_config); }
// Regression test for LP:#1340669 // Test is not deterministic since we are testing a race, but failure can be // reproduced easily with repeated runs. TEST_F(ClientWithCustomDisplayConfiguration, does_not_deadlock_server_with_existing_client_when_disconnecting) { auto second_connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__); auto second_surface = mtf::make_any_surface(connection); ASSERT_TRUE(mir_surface_is_valid(second_surface)); auto configuration = mir_connection_create_display_config(connection); mir_wait_for(mir_connection_apply_display_config(connection, configuration)); EXPECT_STREQ("", mir_connection_get_error_message(connection)); mir_display_config_destroy(configuration); mir_connection_release(second_connection); // Server (and therefore the test) will deadlock and won't be able to // shut down without the fix. It's not ideal to deadlock on test failure, // but it's the best check we have at the moment. }
SDL_Surface* Mir_SetVideoMode(_THIS, SDL_Surface* current, int width, int height, int bpp, Uint32 flags) { if (this->hidden->surface && mir_surface_is_valid(this->hidden->surface)) { mir_surface_release_sync(this->hidden->surface); this->hidden->surface = NULL; } Uint32 output_id = mir_display_output_id_invalid; if (flags & SDL_FULLSCREEN) { MirDisplayConfiguration* display_config = mir_connection_create_display_config(this->hidden->connection); Uint32 fallback_output_id = mir_display_output_id_invalid; Uint32 d; Uint32 m; this->hidden->mode_changed = SDL_FALSE; for (d = 0; d < display_config->num_outputs; ++d) { MirDisplayOutput const* out = display_config->outputs + d; if (out->used && out->connected) { if (out->modes[out->current_mode].horizontal_resolution == width && out->modes[out->current_mode].vertical_resolution == height) { output_id = out->output_id; break; } if (fallback_output_id == mir_display_output_id_invalid && out->modes[out->current_mode].horizontal_resolution >= width && out->modes[out->current_mode].vertical_resolution >= height) { fallback_output_id = out->output_id; } } } if (output_id == mir_display_output_id_invalid) { for (d = 0; d < display_config->num_outputs; ++d) { MirDisplayOutput* out = display_config->outputs + d; if (out->used && out->connected) { for (m = 0; m < out->num_modes; ++m) { if (out->modes[m].horizontal_resolution == width && out->modes[m].vertical_resolution == height) { this->hidden->mode_changed = SDL_TRUE; output_id = out->output_id; out->current_mode = m; mir_wait_for( mir_connection_apply_display_config(this->hidden->connection, display_config) ); break; } } } } } if (fallback_output_id == mir_display_output_id_invalid) { /* There's no native resolution for the requested format, so let's * just ensure we've an output large enough to show it */ for (d = 0; d < display_config->num_outputs; ++d) { MirDisplayOutput* out = display_config->outputs + d; if (out->used && out->connected) { for (m = 0; m < out->num_modes; ++m) { if (out->modes[m].horizontal_resolution >= width && out->modes[m].vertical_resolution >= height) { this->hidden->mode_changed = SDL_TRUE; fallback_output_id = out->output_id; out->current_mode = m; mir_wait_for( mir_connection_apply_display_config(this->hidden->connection, display_config) ); break; } } } } /* Setting output_id = fallback_output_id here seems to cause * troubles to mir in creating a new surface */ } mir_display_config_destroy(display_config); if (output_id == mir_display_output_id_invalid && fallback_output_id == mir_display_output_id_invalid) { SDL_SetError("Impossible to find a valid output for mode %dx%d", width, height); return NULL; } } else if (this->hidden->mode_changed) { Uint32 d; SDL_bool any_changed = SDL_FALSE; MirDisplayConfiguration* display_config = mir_connection_create_display_config(this->hidden->connection); for (d = 0; d < display_config->num_outputs; ++d) { MirDisplayOutput* out = display_config->outputs + d; if (out->used && out->connected) { if (out->current_mode != out->preferred_mode) { out->current_mode = out->preferred_mode; any_changed = SDL_TRUE; } } } if (any_changed) { mir_wait_for( mir_connection_apply_display_config(this->hidden->connection, display_config) ); } this->hidden->mode_changed = SDL_FALSE; mir_display_config_destroy(display_config); } MirSurfaceParameters surfaceparm = { .name = "MirSurface", .width = width, .height = height, .pixel_format = this->hidden->pixel_format, .output_id = output_id, .buffer_usage = (flags & SDL_OPENGL) ? mir_buffer_usage_hardware : mir_buffer_usage_software, }; this->hidden->surface = mir_connection_create_surface_sync(this->hidden->connection, &surfaceparm); if (!mir_surface_is_valid(this->hidden->surface)) { const char* error = mir_surface_get_error_message(this->hidden->surface); SDL_SetError("Failed to created a mir surface: %s", error); mir_surface_release_sync(this->hidden->surface); return NULL; } MirEventDelegate delegate = { Mir_HandleSurfaceEvent, NULL }; mir_surface_set_event_handler(this->hidden->surface, &delegate); if (flags & SDL_OPENGL) { current->flags |= SDL_OPENGL; if (Mir_GL_CreateESurface(this) < 0) { SDL_SetError("Could not Create EGL Surface"); return NULL; } if (Mir_GL_CreateContext(this) < 0) { SDL_SetError("Could not Create GL Context"); return NULL; } } else { if ((current->w != width || current->h != height)) { current->pixels = NULL; current->w = width; current->h = height; current->pitch = SDL_CalculatePitch(current); current->pixels = SDL_calloc(1, current->h * current->pitch); if (!current->pixels) { SDL_OutOfMemory(); return NULL; } this->UpdateRects = Mir_UpdateRects; } } return current; } static void Mir_ModeListFree(_THIS) { if (this->hidden->modelist) { int i = 0; while (this->hidden->modelist[i] != NULL) { SDL_free(this->hidden->modelist[i]); ++i; } SDL_free(this->hidden->modelist); this->hidden->modelist = NULL; } } static void Mir_ModeListUpdate(_THIS) { Uint32 d, m; Uint32 valid_outputs = 0; Mir_ModeListFree(this); MirDisplayConfiguration* display_config = mir_connection_create_display_config(this->hidden->connection); for (d = 0; d < display_config->num_outputs; d++) { MirDisplayOutput const* out = display_config->outputs + d; if (out->used && out->connected) valid_outputs += out->num_modes; } this->hidden->modelist = SDL_calloc(valid_outputs + 1, sizeof(SDL_Rect*)); valid_outputs = 0; for (d = 0; d < display_config->num_outputs; ++d) { MirDisplayOutput const* out = display_config->outputs + d; if (out->used && out->connected) { for (m = 0; m < out->num_modes; ++m) { SDL_Rect* sdl_output = SDL_calloc(1, sizeof(SDL_Rect)); sdl_output->x = out->position_x; sdl_output->y = out->position_y; sdl_output->w = out->modes[m].horizontal_resolution; sdl_output->h = out->modes[m].vertical_resolution; this->hidden->modelist[valid_outputs] = sdl_output; ++valid_outputs; } } } this->hidden->modelist[valid_outputs] = NULL; mir_display_config_destroy(display_config); }