leyoda/cosmic-comp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: update smithay + switch to tracing

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-02-24 17:41:52 +01:00
parent 844ed552b9
commit 35de500c00
35 changed files with 622 additions and 754 deletions
Download patch file Download diff file Expand all files Collapse all files

125
src/backend/kms/mod.rs
View file

@ -55,6 +55,7 @@ use smithay::{
wayland::{dmabuf::DmabufGlobal, seat::WaylandFocus},
xwayland::XWaylandClientData,
};
use tracing::{debug, error, info, warn};
use std::{
cell::RefCell,
@ -112,15 +113,15 @@ pub fn init_backend(
event_loop: &mut EventLoop<'static, Data>,
state: &mut State,
) -> Result<()> {
let (session, notifier) = LibSeatSession::new(None).context("Failed to acquire session")?;
let (session, notifier) = LibSeatSession::new().context("Failed to acquire session")?;
let udev_backend = UdevBackend::new(session.seat(), None)?;
let udev_backend = UdevBackend::new(session.seat())?;
let mut libinput_context =
Libinput::new_with_udev::<LibinputSessionInterface<LibSeatSession>>(session.clone().into());
libinput_context
.udev_assign_seat(&session.seat())
.map_err(|_| anyhow::anyhow!("Failed to assign seat to libinput"))?;
let libinput_backend = LibinputInputBackend::new(libinput_context.clone(), None);
let libinput_backend = LibinputInputBackend::new(libinput_context.clone());
let libinput_event_source = event_loop
.handle()
@ -136,17 +137,17 @@ pub fn init_backend(
None,
None,
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
})
.map_err(|err| err.error)
.context("Failed to initialize libinput event source")?;
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default(), None)
let api = GpuManager::new(GbmGlesBackend::<GlowRenderer>::default())
.context("Failed to initialize renderers")?;
// TODO get this info from system76-power, if available and setup a watcher
@ -173,7 +174,7 @@ pub fn init_backend(
panic!("Failed to initialize any GPU");
})
};
slog_scope::info!("Using {} as primary gpu for rendering", primary);
info!("Using {} as primary gpu for rendering.", primary);
let udev_dispatcher = Dispatcher::new(udev_backend, move |event, _, data: &mut Data| {
match match event {
@ -191,10 +192,10 @@ pub fn init_backend(
.with_context(|| format!("Failed to remove drm device: {}", device_id)),
} {
Ok(()) => {
slog_scope::debug!("Successfully handled udev event")
debug!("Successfully handled udev event.")
}
Err(err) => {
slog_scope::error!("Error while handling udev event: {}", err)
error!(?err, "Error while handling udev event.")
}
}
});
@ -211,7 +212,7 @@ pub fn init_backend(
.insert_source(notifier, move |event, &mut (), data| match event {
SessionEvent::ActivateSession => {
if let Err(err) = libinput_context.resume() {
slog_scope::error!("Failed to resume libinput context: {:?}", err);
error!(?err, "Failed to resume libinput context.");
}
for device in data.state.backend.kms().devices.values() {
device.drm.as_source_ref().activate();
@ -222,21 +223,13 @@ pub fn init_backend(
let drm_node = match DrmNode::from_dev_id(dev) {
Ok(node) => node,
Err(err) => {
slog_scope::error!(
"Failed to read drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to read drm device {}.", path.display(),);
continue;
}
};
if data.state.backend.kms().devices.contains_key(&drm_node) {
if let Err(err) = data.state.device_changed(dev) {
slog_scope::error!(
"Failed to update drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to update drm device {}.", path.display(),);
}
} else {
if let Err(err) = data.state.device_added(
@ -245,11 +238,7 @@ pub fn init_backend(
&data.display.handle(),
true,
) {
slog_scope::error!(
"Failed to add drm device {}: {}",
path.display(),
err
);
error!(?err, "Failed to add drm device {}.", path.display(),);
}
}
}
@ -284,10 +273,10 @@ pub fn init_backend(
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -352,27 +341,24 @@ impl State {
return Ok(());
}
let fd = DrmDeviceFd::new(
unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
let fd = DrmDeviceFd::new(unsafe {
DeviceFd::from_raw_fd(
self.backend
.kms()
.session
.open(
&path,
OFlag::O_RDWR | OFlag::O_CLOEXEC | OFlag::O_NOCTTY | OFlag::O_NONBLOCK,
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
.with_context(|| {
format!(
"Failed to optain file descriptor for drm device: {}",
path.display()
)
})?,
)
},
None,
);
let drm = DrmDevice::new(fd.clone(), false, None)
})?,
)
});
let drm = DrmDevice::new(fd.clone(), false)
.with_context(|| format!("Failed to initialize drm device for: {}", path.display()))?;
let drm_node = DrmNode::from_dev_id(dev)?;
let supports_atomic = drm.is_atomic();
@ -380,7 +366,7 @@ impl State {
let gbm = GbmDevice::new(fd)
.with_context(|| format!("Failed to initialize GBM device for {}", path.display()))?;
let (render_node, formats) = {
let egl_display = EGLDisplay::new(gbm.clone(), None).with_context(|| {
let egl_display = EGLDisplay::new(gbm.clone()).with_context(|| {
format!("Failed to create EGLDisplay for device: {}", path.display())
})?;
let egl_device = EGLDevice::device_for_display(&egl_display).with_context(|| {
@ -391,7 +377,7 @@ impl State {
.ok()
.and_then(std::convert::identity)
.unwrap_or(drm_node);
let egl_context = EGLContext::new(&egl_display, None).with_context(|| {
let egl_context = EGLContext::new(&egl_display).with_context(|| {
format!(
"Failed to create EGLContext for device {:?}:{}",
egl_device,
@ -458,7 +444,7 @@ impl State {
})
}
Some(Err(err)) => {
slog_scope::warn!("Failed to submit frame: {}", err);
warn!(?err, "Failed to submit frame.");
None
}
_ => None, // got disabled
@ -487,12 +473,12 @@ impl State {
Some(repaint_delay),
scheduled_sessions,
) {
slog_scope::warn!("Failed to schedule render: {}", err);
warn!(?err, "Failed to schedule render.");
}
}
}
DrmEvent::Error(err) => {
slog_scope::warn!("Failed to read events of device {:?}: {}", dev, err);
warn!(?err, "Failed to read events of device {:?}.", dev);
}
});
let token = self
@ -504,10 +490,9 @@ impl State {
let socket = match self.create_socket(dh, render_node, formats.clone().into_iter()) {
Ok(socket) => Some(socket),
Err(err) => {
slog_scope::warn!(
"Failed to initialize hardware-acceleration for clients on {}: {}",
render_node,
err
warn!(
?err,
"Failed to initialize hardware-acceleration for clients on {}.", render_node,
);
None
}
@ -548,7 +533,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -563,7 +548,7 @@ impl State {
.w;
wl_outputs.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
backend.devices.insert(drm_node, device);
@ -589,7 +574,7 @@ impl State {
}
fn init_vulkan(&mut self, drm_node: DrmNode, render_node: DrmNode) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None, None) {
if let Ok(instance) = Instance::new(Version::VERSION_1_2, None) {
if let Some(physical_device) =
PhysicalDevice::enumerate(&instance)
.ok()
@ -621,7 +606,7 @@ impl State {
.allocator = Box::new(DmabufAllocator(allocator));
}
Err(err) => {
slog_scope::warn!("Failed to create vulkan allocator: {}", err);
warn!(?err, "Failed to create vulkan allocator.");
}
}
}
@ -654,7 +639,7 @@ impl State {
let mut renderer = match backend.api.single_renderer(&device.render_node) {
Ok(renderer) => renderer,
Err(err) => {
slog_scope::warn!("Failed to initialize output: {}", err);
warn!(?err, "Failed to initialize output.");
continue;
}
};
@ -669,7 +654,7 @@ impl State {
.w;
outputs_added.push(output);
}
Err(err) => slog_scope::warn!("Failed to initialize output: {}", err),
Err(err) => warn!(?err, "Failed to initialize output."),
};
}
}
@ -826,7 +811,6 @@ impl Device {
.map(|info| info.model.clone())
.unwrap_or_else(|_| String::from("Unknown")),
},
None,
);
for mode in conn_info.modes() {
let refresh_rate = drm_helpers::calculate_refresh_rate(*mode);
@ -1059,7 +1043,6 @@ impl KmsState {
GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
),
device.formats.clone(),
None,
)
.with_context(|| {
format!(
@ -1094,10 +1077,10 @@ impl KmsState {
None
},
) {
slog_scope::crit!(
"Error scheduling event loop for output {}: {:?}",
error!(
?err,
"Error scheduling event loop for output {}.",
output.name(),
err
);
}
}
@ -1135,7 +1118,7 @@ impl KmsState {
render,
surface,
) {
slog_scope::debug!("Early import failed: {}", err);
debug!(?err, "Early import failed.");
}
}
@ -1247,7 +1230,7 @@ impl KmsState {
}
Err(err) => {
if backend.session.is_active() {
slog_scope::error!("Error rendering: {:?}", err);
error!(?err, "Error rendering.");
return TimeoutAction::ToDuration(Duration::from_secs_f64(
(1000.0 / surface.refresh_rate as f64) - 0.003,
));

14
src/backend/kms/socket.rs
View file

@ -14,6 +14,7 @@ use smithay::{
xwayland::XWaylandClientData,
};
use std::sync::Arc;
use tracing::{info, warn};
use crate::{
state::{ClientState, Data},
@ -61,7 +62,7 @@ impl State {
let dmabuf_global = self
.common
.dmabuf_state
.create_global_with_filter::<State, _, _>(dh, formats.clone(), filter, None);
.create_global_with_filter::<State, _>(dh, formats.clone(), filter);
let drm_global_id = self
.common
@ -81,8 +82,9 @@ impl State {
);
// add a special socket for the gpu
let listener = ListeningSocketSource::with_name(&socket_name, None)
let listener = ListeningSocketSource::with_name(&socket_name)
.with_context(|| format!("Failed to bind socket to {}", socket_name))?;
let socket_name_clone = socket_name.clone();
let token = self
.common
.event_loop_handle
@ -91,12 +93,16 @@ impl State {
client_stream,
Arc::new(data.state.new_client_state_with_node(render_node)),
) {
slog_scope::warn!("Error adding wayland client ({}): {}", render_node, err);
warn!(
socket_name = socket_name_clone,
?err,
"Error adding wayland client."
);
}
})
.context("Failed to add gpu-wayland socket to the event loop")?;
slog_scope::info!("Added socket at {} for gpu {}", socket_name, render_node,);
info!(socket_name, ?render_node, "Added gpu-specific socket.");
Ok(Socket {
token,

5
src/backend/mod.rs
View file

@ -3,6 +3,7 @@
use crate::state::{Data, State};
use anyhow::{Context, Result};
use smithay::reexports::{calloop::EventLoop, wayland_server::DisplayHandle};
use tracing::{info, warn};
pub mod render;
@ -29,8 +30,8 @@ pub fn init_backend_auto(
match x11::init_backend(dh, event_loop, state) {
Ok(_) => Ok(()),
Err(err) => {
slog_scope::warn!("X11 Backend failed with error: {}", err);
slog_scope::info!("Falling back to winit backend.");
warn!(?err, "Initializing X11 Backend failed.");
info!("Falling back to winit backend.");
winit::init_backend(dh, event_loop, state)
}
}

10
src/backend/render/cursor.rs
View file

@ -26,6 +26,7 @@ use std::{
sync::Mutex,
time::Duration,
};
use tracing::warn;
use xcursor::{
parser::{parse_xcursor, Image},
CursorTheme,
@ -51,9 +52,7 @@ impl Cursor {
let theme = CursorTheme::load(&name);
let icons = load_icon(&theme)
.map_err(|err| {
slog_scope::warn!("Unable to load xcursor: {}, using fallback cursor", err)
})
.map_err(|err| warn!(?err, "Unable to load xcursor, using fallback cursor"))
.unwrap_or_else(|_| {
vec![Image {
size: 32,
@ -160,7 +159,6 @@ where
surface,
position.to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}
@ -175,7 +173,8 @@ where
<R as Renderer>::TextureId: 'static,
{
if get_role(&surface) != Some("dnd_icon") {
slog_scope::warn!(
warn!(
?surface,
"Trying to display as a dnd icon a surface that does not have the DndIcon role."
);
}
@ -185,7 +184,6 @@ where
surface,
location.into().to_physical_precise_round(scale),
scale,
slog_scope::logger(),
)
}

29
src/backend/render/element.rs
View file

@ -127,23 +127,19 @@ impl RenderElement<GlowRenderer> for CosmicElement<GlowRenderer> {
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlowRenderer as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, frame, src, dst, damage)
}
}
}
fn underlying_storage(
&self,
renderer: &GlowRenderer,
) -> Option<UnderlyingStorage<'_, GlowRenderer>> {
fn underlying_storage(&self, renderer: &mut GlowRenderer) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
@ -161,17 +157,16 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
src: Rectangle<f64, BufferCoords>,
dst: Rectangle<i32, Physical>,
damage: &[Rectangle<i32, Physical>],
log: &slog::Logger,
) -> Result<(), <GlMultiRenderer<'a, 'b> as Renderer>::Error> {
match self {
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage, log),
CosmicElement::Workspace(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::Cursor(elem) => elem.draw(frame, src, dst, damage),
CosmicElement::MoveGrab(elem) => elem.draw(frame, src, dst, damage),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let elem = {
let glow_frame = frame.glow_frame_mut();
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage, log)
RenderElement::<GlowRenderer>::draw(elem, glow_frame, src, dst, damage)
.map_err(|err| MultiError::Render(err))
};
elem
@ -181,15 +176,15 @@ impl<'a, 'b> RenderElement<GlMultiRenderer<'a, 'b>> for CosmicElement<GlMultiRen
fn underlying_storage(
&self,
renderer: &GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage<'_, GlMultiRenderer<'a, 'b>>> {
renderer: &mut GlMultiRenderer<'a, 'b>,
) -> Option<UnderlyingStorage> {
match self {
CosmicElement::Workspace(elem) => elem.underlying_storage(renderer),
CosmicElement::Cursor(elem) => elem.underlying_storage(renderer),
CosmicElement::MoveGrab(elem) => elem.underlying_storage(renderer),
#[cfg(feature = "debug")]
CosmicElement::Egui(elem) => {
let glow_renderer = renderer.glow_renderer();
let glow_renderer = renderer.glow_renderer_mut();
match elem.underlying_storage(glow_renderer) {
Some(UnderlyingStorage::Wayland(buffer)) => {
Some(UnderlyingStorage::Wayland(buffer))

7
src/backend/render/mod.rs
View file

@ -37,6 +37,7 @@ use smithay::{
utils::{Physical, Rectangle},
wayland::dmabuf::get_dmabuf,
};
use tracing::warn;
pub mod cursor;
use self::cursor::CursorRenderElement;
@ -268,7 +269,7 @@ where
}
renderer.bind(target).map_err(RenderError::Rendering)?;
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR, None);
let res = damage_tracker.render_output(renderer, age, &elements, CLEAR_COLOR);
if let Some(fps) = fps.as_mut() {
fps.render();
@ -284,7 +285,7 @@ where
params,
output.current_transform(),
|_node, buffer, renderer, dtr, age| {
let res = dtr.damage_output(age, &elements, slog_scope::logger())?;
let res = dtr.damage_output(age, &elements)?;
if let (Some(ref damage), _) = &res {
if let Ok(dmabuf) = get_dmabuf(buffer) {
@ -311,7 +312,7 @@ where
Ok(true) => {} // success
Ok(false) => state.still_pending(session.clone(), params.clone()),
Err(err) => {
slog_scope::warn!("Error rendering to screencopy session: {}", err);
warn!(?err, "Error rendering to screencopy session.");
session.failed(FailureReason::Unspec);
}
}

13
src/backend/winit.rs
View file

@ -27,6 +27,7 @@ use smithay::{
utils::Transform,
};
use std::cell::RefCell;
use tracing::{error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -145,7 +146,7 @@ pub fn init_backend(
state: &mut State,
) -> Result<()> {
let (mut backend, mut input) =
winit::init(None).map_err(|_| anyhow!("Failed to initilize winit backend"))?;
winit::init().map_err(|_| anyhow!("Failed to initilize winit backend"))?;
init_egl_client_side(dh, state, &mut backend)?;
@ -161,7 +162,7 @@ pub fn init_backend(
size: (size.physical_size.w as i32, size.physical_size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -197,7 +198,7 @@ pub fn init_backend(
.winit()
.render_output(&mut data.state.common)
{
slog_scope::error!("Failed to render frame: {}", err);
error!(?err, "Failed to render frame.");
render_ping.ping();
}
})
@ -269,7 +270,7 @@ fn init_egl_client_side(
let bind_result = renderer.renderer().bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer
.renderer()
.dmabuf_formats()
@ -278,9 +279,9 @@ fn init_egl_client_side(
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())

37
src/backend/x11.rs
View file

@ -37,6 +37,7 @@ use smithay::{
utils::{DeviceFd, Transform},
};
use std::{cell::RefCell, os::unix::io::OwnedFd};
use tracing::{debug, error, info, warn};
#[cfg(feature = "debug")]
use crate::state::Fps;
@ -96,7 +97,7 @@ impl X11State {
size: (size.w as i32, size.h as i32).into(),
refresh: 60_000,
};
let output = Output::new(name, props, None);
let output = Output::new(name, props);
output.add_mode(mode);
output.set_preferred(mode);
output.change_current_state(
@ -126,7 +127,7 @@ impl X11State {
if let Err(err) =
surface.render_output(&mut x11_state.renderer, &mut data.state.common)
{
slog_scope::error!("Error rendering: {}", err);
error!(?err, "Error rendering.");
}
surface.dirty = false;
surface.pending = true;
@ -272,12 +273,12 @@ impl Surface {
}
fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let instance = match Instance::new(Version::VERSION_1_2, None, None) {
let instance = match Instance::new(Version::VERSION_1_2, None) {
Ok(instance) => instance,
Err(err) => {
slog_scope::warn!(
"Failed to instanciate vulkan, falling back to gbm allocator: {}",
err
warn!(
?err,
"Failed to instanciate vulkan, falling back to gbm allocator.",
);
return None;
}
@ -286,7 +287,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
let devices = match PhysicalDevice::enumerate(&instance) {
Ok(devices) => devices,
Err(err) => {
slog_scope::debug!("No vulkan devices, falling back to gbm: {}", err);
debug!(?err, "No vulkan devices, falling back to gbm.");
return None;
}
};
@ -299,7 +300,7 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
phd.primary_node().unwrap() == Some(*node) || phd.render_node().unwrap() == Some(*node)
})
else {
slog_scope::debug!("No vulkan device for node {:?}, falling back to gbm", node);
debug!(?node, "No vulkan device for node, falling back to gbm.");
return None;
};
@ -308,10 +309,10 @@ fn try_vulkan_allocator(node: &DrmNode) -> Option<Allocator> {
fn try_gbm_allocator(fd: OwnedFd) -> Option<Allocator> {
// Create the gbm device for buffer allocation.
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd), None)) {
let device = match GbmDevice::new(DrmDeviceFd::new(DeviceFd::from(fd))) {
Ok(gbm) => gbm,
Err(err) => {
slog_scope::error!("Failed to create GBM device: {}", err);
error!(?err, "Failed to create GBM device.");
return None;
}
};
@ -327,7 +328,7 @@ pub fn init_backend(
event_loop: &mut EventLoop<Data>,
state: &mut State,
) -> Result<()> {
let backend = X11Backend::new(None).with_context(|| "Failed to initilize X11 backend")?;
let backend = X11Backend::new().with_context(|| "Failed to initilize X11 backend")?;
let handle = backend.handle();
// Obtain the DRM node the X server uses for direct rendering.
@ -340,12 +341,12 @@ pub fn init_backend(
.find(|device| device.try_get_render_node().ok().flatten() == Some(drm_node))
.with_context(|| format!("Failed to find EGLDevice for node {}", drm_node))?;
// Initialize EGL
let egl = EGLDisplay::new(device, None).with_context(|| "Failed to create EGL display")?;
let egl = EGLDisplay::new(device).with_context(|| "Failed to create EGL display")?;
// Create the OpenGL context
let context = EGLContext::new(&egl, None).with_context(|| "Failed to create EGL context")?;
let context = EGLContext::new(&egl).with_context(|| "Failed to create EGL context")?;
// Create a renderer
let mut renderer = unsafe { GlowRenderer::new(context, None) }
.with_context(|| "Failed to initialize renderer")?;
let mut renderer =
unsafe { GlowRenderer::new(context) }.with_context(|| "Failed to initialize renderer")?;
init_egl_client_side(dh, state, &mut renderer)?;
@ -478,14 +479,14 @@ where
let bind_result = renderer.bind_wl_display(dh);
match bind_result {
Ok(_) => {
slog_scope::info!("EGL hardware-acceleration enabled");
info!("EGL hardware-acceleration enabled.");
let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
state
.common
.dmabuf_state
.create_global::<State, _>(dh, dmabuf_formats, None);
.create_global::<State>(dh, dmabuf_formats);
}
Err(err) => slog_scope::warn!("Unable to initialize bind display to EGL: {}", err),
Err(err) => warn!(?err, "Unable to initialize bind display to EGL."),
};
Ok(())