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

Update smithay for 10-bit color support

Browse source
This commit is contained in:
Victoria Brekenfeld 2023-04-18 17:10:21 +02:00
parent 8f6ad62017
commit b98ca9c493
12 changed files with 384 additions and 186 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -34,7 +34,7 @@ use smithay::{
renderer::{
buffer_dimensions,
damage::{Error as RenderError, OutputNoMode},
gles2::Gles2Renderbuffer,
gles::GlesRenderbuffer,
glow::GlowRenderer,
multigpu::{gbm::GbmGlesBackend, Error as MultiError, GpuManager},
utils::draw_render_elements,
@ -69,6 +69,7 @@ use smithay::{
dmabuf::{get_dmabuf, DmabufFeedbackBuilder, DmabufGlobal},
relative_pointer::RelativePointerManagerState,
seat::WaylandFocus,
shm::{shm_format_to_fourcc, with_buffer_contents},
},
xwayland::XWaylandClientData,
};
@ -1052,7 +1053,7 @@ impl Surface {
})?;
self.fps.elements();
let res = compositor.render_frame::<_, _, Gles2Renderbuffer>(
let res = compositor.render_frame::<_, _, GlesRenderbuffer>(
&mut renderer,
&elements,
CLEAR_COLOR,
@ -1083,9 +1084,13 @@ impl Surface {
renderer.bind(dmabuf).map_err(RenderError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| OutputNoMode)? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<Gles2Renderbuffer>::create_buffer(
renderer, size,
Offscreen::<GlesRenderbuffer>::create_buffer(
renderer, format, size,
)
.map_err(RenderError::Rendering)?;
renderer
@ -1160,13 +1165,11 @@ impl Surface {
.single_renderer(&source_node)
.unwrap()
.dmabuf_formats()
.copied()
.collect::<HashSet<_>>();
let target_formats = api
.single_renderer(target_node)
.unwrap()
.dmabuf_formats()
.copied()
.collect::<HashSet<_>>();
get_surface_dmabuf_feedback(
source_node,
@ -1293,7 +1296,12 @@ impl KmsState {
GbmBufferFlags::RENDERING | GbmBufferFlags::SCANOUT,
),
device.gbm.clone(),
&[Fourcc::Abgr8888, Fourcc::Argb8888],
&[
Fourcc::Abgr2101010,
Fourcc::Argb2101010,
Fourcc::Abgr8888,
Fourcc::Argb8888,
],
device.formats.clone(),
drm.cursor_size(),
Some(device.gbm.clone()),

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

@ -2,12 +2,15 @@
use crate::utils::prelude::*;
use smithay::{
backend::renderer::{
element::{
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
texture::{TextureBuffer, TextureRenderElement},
backend::{
allocator::Fourcc,
renderer::{
element::{
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
texture::{TextureBuffer, TextureRenderElement},
},
ImportAll, ImportMem, Renderer,
},
ImportAll, ImportMem, Renderer,
},
input::{
pointer::{CursorImageAttributes, CursorImageStatus},
@ -264,6 +267,7 @@ where
let texture = TextureBuffer::from_memory(
renderer,
&frame.pixels_rgba,
Fourcc::Abgr8888,
(frame.width as i32, frame.height as i32),
false,
integer_scale as i32,

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

@ -37,8 +37,8 @@ use smithay::{
buffer_dimensions,
damage::{Error as RenderError, OutputDamageTracker, OutputNoMode},
element::{Element, RenderElement, RenderElementStates},
gles2::{
element::PixelShaderElement, Gles2Error, Gles2PixelProgram, Gles2Renderer, Uniform,
gles::{
element::PixelShaderElement, GlesError, GlesPixelProgram, GlesRenderer, Uniform,
UniformName, UniformType,
},
glow::GlowRenderer,
@ -48,7 +48,10 @@ use smithay::{
},
output::Output,
utils::{Logical, Physical, Point, Rectangle, Size},
wayland::dmabuf::get_dmabuf,
wayland::{
dmabuf::get_dmabuf,
shm::{shm_format_to_fourcc, with_buffer_contents},
},
};
use tracing::warn;
@ -66,12 +69,12 @@ pub static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
pub static FOCUS_INDICATOR_COLOR: [f32; 4] = [0.580, 0.921, 0.921, 1.0];
pub static FOCUS_INDICATOR_SHADER: &str = include_str!("./shaders/focus_indicator.frag");
pub struct IndicatorShader(pub Gles2PixelProgram);
pub struct IndicatorShader(pub GlesPixelProgram);
struct IndicatorElement(pub RefCell<PixelShaderElement>);
impl IndicatorShader {
pub fn get<R: AsGlowRenderer>(renderer: &R) -> Gles2PixelProgram {
Borrow::<Gles2Renderer>::borrow(renderer.glow_renderer())
pub fn get<R: AsGlowRenderer>(renderer: &R) -> GlesPixelProgram {
Borrow::<GlesRenderer>::borrow(renderer.glow_renderer())
.egl_context()
.user_data()
.get::<IndicatorShader>()
@ -93,7 +96,7 @@ impl IndicatorShader {
geo.size + Size::from(thickness_size),
);
let user_data = Borrow::<Gles2Renderer>::borrow(renderer.glow_renderer())
let user_data = Borrow::<GlesRenderer>::borrow(renderer.glow_renderer())
.egl_context()
.user_data();
@ -129,9 +132,9 @@ impl IndicatorShader {
}
}
pub fn init_shaders<R: AsGlowRenderer>(renderer: &mut R) -> Result<(), Gles2Error> {
pub fn init_shaders<R: AsGlowRenderer>(renderer: &mut R) -> Result<(), GlesError> {
let glow_renderer = renderer.glow_renderer_mut();
let gles_renderer: &mut Gles2Renderer = glow_renderer.borrow_mut();
let gles_renderer: &mut GlesRenderer = glow_renderer.borrow_mut();
let indicator_shader = gles_renderer.compile_custom_pixel_shader(
FOCUS_INDICATOR_SHADER,
@ -234,7 +237,7 @@ pub fn workspace_elements<R>(
where
R: Renderer + ImportAll + ImportMem + AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
{
@ -333,7 +336,7 @@ where
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
@ -383,7 +386,7 @@ where
+ Blit<Source>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
@ -456,8 +459,12 @@ where
renderer.bind(dmabuf).map_err(RenderError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| OutputNoMode)? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer = renderer
.create_buffer(size)
.create_buffer(format, size)
.map_err(RenderError::Rendering)?;
renderer
.bind(render_buffer)

10
src/backend/winit.rs
View file

@ -13,7 +13,7 @@ use smithay::{
backend::{
egl::EGLDevice,
renderer::{
damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, ImportDma,
damage::OutputDamageTracker, gles::GlesRenderbuffer, glow::GlowRenderer, ImportDma,
ImportEgl,
},
winit::{self, WinitEvent, WinitGraphicsBackend, WinitVirtualDevice},
@ -54,7 +54,7 @@ impl WinitState {
let age = self.backend.buffer_age().unwrap_or(0);
let surface = self.backend.egl_surface();
match render::render_output::<_, _, Gles2Renderbuffer, _>(
match render::render_output::<_, _, GlesRenderbuffer, _>(
None,
self.backend.renderer(),
surface.clone(),
@ -273,11 +273,7 @@ fn init_egl_client_side(
let render_node = EGLDevice::device_for_display(renderer.renderer().egl_context().display())
.and_then(|device| device.try_get_render_node());
let dmabuf_formats = renderer
.renderer()
.dmabuf_formats()
.cloned()
.collect::<Vec<_>>();
let dmabuf_formats = renderer.renderer().dmabuf_formats().collect::<Vec<_>>();
let dmabuf_default_feedback = match render_node {
Ok(Some(node)) => {
let dmabuf_default_feedback =

12
src/backend/x11.rs
View file

@ -20,7 +20,7 @@ use smithay::{
egl::{EGLContext, EGLDevice, EGLDisplay},
input::{Event, InputEvent},
renderer::{
damage::OutputDamageTracker, gles2::Gles2Renderbuffer, glow::GlowRenderer, Bind,
damage::OutputDamageTracker, gles::GlesRenderbuffer, glow::GlowRenderer, Bind,
ImportDma, ImportEgl,
},
vulkan::{version::Version, Instance, PhysicalDevice},
@ -221,7 +221,7 @@ impl Surface {
.surface
.buffer()
.with_context(|| "Failed to allocate buffer")?;
match render::render_output::<_, _, Gles2Renderbuffer, _>(
match render::render_output::<_, _, GlesRenderbuffer, _>(
None,
renderer,
buffer.clone(),
@ -490,11 +490,11 @@ where
"Unable to initialize bind display to EGL. Some older clients may not work correctly."
)
}
let dmabuf_formats = renderer.dmabuf_formats().cloned().collect::<Vec<_>>();
let default_feedback = DmabufFeedbackBuilder::new(render_node.dev_id(), dmabuf_formats.clone())
.build()
.unwrap();
let default_feedback =
DmabufFeedbackBuilder::new(render_node.dev_id(), renderer.dmabuf_formats())
.build()
.unwrap();
state
.common
.dmabuf_state

2
src/shell/element/mod.rs
View file

@ -12,7 +12,7 @@ use smithay::{
input::KeyState,
renderer::{
element::{AsRenderElements, Element, RenderElement, UnderlyingStorage},
gles2::element::PixelShaderElement,
gles::element::PixelShaderElement,
glow::GlowRenderer,
multigpu::Error as MultiError,
ImportAll, ImportMem, Renderer,

20
src/utils/iced.rs
View file

@ -28,6 +28,7 @@ use iced_softbuffer::{
use ordered_float::OrderedFloat;
use smithay::{
backend::{
allocator::Fourcc,
input::{ButtonState, KeyState},
renderer::{
element::{
@ -222,7 +223,8 @@ impl<P: Program + Send + 'static> IcedElement<P> {
.to_f64()
.to_buffer(**scale, Transform::Normal)
.to_i32_round();
*buffer = MemoryRenderBuffer::new(buffer_size, 1, Transform::Normal, None);
*buffer =
MemoryRenderBuffer::new(Fourcc::Argb8888, buffer_size, 1, Transform::Normal, None);
*needs_redraw = true;
}
internal_ref.update(true);
@ -488,7 +490,13 @@ impl<P: Program + Send + 'static> SpaceElement for IcedElement<P> {
internal.buffers.insert(
OrderedFloat(scale),
(
MemoryRenderBuffer::new(buffer_size, 1, Transform::Normal, None),
MemoryRenderBuffer::new(
Fourcc::Argb8888,
buffer_size,
1,
Transform::Normal,
None,
),
true,
),
);
@ -532,7 +540,13 @@ impl<P: Program + Send + 'static> SpaceElement for IcedElement<P> {
internal_ref.buffers.insert(
scale,
(
MemoryRenderBuffer::new(buffer_size, 1, Transform::Normal, None),
MemoryRenderBuffer::new(
Fourcc::Argb8888,
buffer_size,
1,
Transform::Normal,
None,
),
true,
),
);

3
src/wayland/handlers/data_device.rs
View file

@ -57,7 +57,7 @@ impl DataDeviceHandler for State {
&self.common.data_device_state
}
fn new_selection(&mut self, source: Option<WlDataSource>) {
fn new_selection(&mut self, source: Option<WlDataSource>, _seat: Seat<State>) {
if let Some(state) = self.common.xwayland_state.as_mut() {
if let Some(xwm) = state.xwm.as_mut() {
if let Some(source) = &source {
@ -80,6 +80,7 @@ impl DataDeviceHandler for State {
&mut self,
mime_type: String,
fd: OwnedFd,
_seat: Seat<State>,
_user_data: &Self::SelectionUserData,
) {
if let Some(xwm) = self

5
src/wayland/handlers/primary_selection.rs
View file

@ -3,7 +3,7 @@
use crate::state::State;
use smithay::{
delegate_primary_selection,
wayland::primary_selection::{PrimarySelectionHandler, PrimarySelectionState, with_source_metadata}, xwayland::xwm::{XwmId, SelectionType}, reexports::wayland_protocols::wp::primary_selection::zv1::server::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1,
wayland::primary_selection::{PrimarySelectionHandler, PrimarySelectionState, with_source_metadata}, xwayland::xwm::{XwmId, SelectionType}, reexports::wayland_protocols::wp::primary_selection::zv1::server::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1, input::Seat,
};
use tracing::warn;
@ -16,7 +16,7 @@ impl PrimarySelectionHandler for State {
&self.common.primary_selection_state
}
fn new_selection(&mut self, source: Option<ZwpPrimarySelectionSourceV1>) {
fn new_selection(&mut self, source: Option<ZwpPrimarySelectionSourceV1>, _seat: Seat<State>) {
if let Some(state) = self.common.xwayland_state.as_mut() {
if let Some(xwm) = state.xwm.as_mut() {
if let Some(source) = &source {
@ -36,6 +36,7 @@ impl PrimarySelectionHandler for State {
&mut self,
mime_type: String,
fd: OwnedFd,
_seat: Seat<State>,
_user_data: &Self::SelectionUserData,
) {
if let Some(xwm) = self

101
src/wayland/handlers/screencopy.rs
View file

@ -1,4 +1,5 @@
use std::{
borrow::Borrow,
cell::RefCell,
collections::HashSet,
ops::{Deref, DerefMut},
@ -16,12 +17,12 @@ use smithay::{
egl::EGLDevice,
renderer::{
buffer_dimensions, buffer_type,
damage::{Error as DTError, OutputDamageTracker},
damage::{Error as DTError, OutputDamageTracker, OutputNoMode},
element::{
surface::WaylandSurfaceRenderElement, AsRenderElements, RenderElement,
RenderElementStates,
},
gles2::{Gles2Error, Gles2Renderbuffer},
gles::{Capability, GlesError, GlesRenderbuffer, GlesRenderer},
Bind, Blit, BufferType, ExportMem, ImportAll, ImportMem, Offscreen, Renderer,
},
},
@ -35,7 +36,7 @@ use smithay::{
wayland::{
dmabuf::get_dmabuf,
seat::WaylandFocus,
shm::{with_buffer_contents, with_buffer_contents_mut},
shm::{shm_format_to_fourcc, with_buffer_contents, with_buffer_contents_mut},
},
xwayland::XWaylandClientData,
};
@ -209,6 +210,24 @@ impl ScreencopyHandler for State {
stride: size.w as u32 * 4,
},
];
if (renderer as &dyn Borrow<GlesRenderer>)
.borrow()
.capabilities()
.contains(&Capability::ColorTransformations)
{
formats.extend([
BufferInfo::Shm {
format: ShmFormat::Abgr2101010,
size,
stride: size.w as u32 * 4,
},
BufferInfo::Shm {
format: ShmFormat::Xbgr2101010,
size,
stride: size.w as u32 * 4,
},
]);
}
if let Some(node) = EGLDevice::device_for_display(renderer.egl_context().display())
.ok()
@ -298,7 +317,10 @@ impl ScreencopyHandler for State {
if let Some(BufferType::Shm) = buffer_type(&params.buffer) {
if with_buffer_contents(&params.buffer, |_, _, info| {
info.format != ShmFormat::Abgr8888 && info.format != ShmFormat::Xbgr8888
info.format != ShmFormat::Abgr8888
&& info.format != ShmFormat::Xbgr8888
&& info.format != ShmFormat::Abgr2101010
&& info.format != ShmFormat::Xbgr2101010
})
.unwrap()
{
@ -449,6 +471,24 @@ fn formats_for_output(
stride: mode.w as u32 * 4,
},
];
if (renderer as &dyn Borrow<GlesRenderer>)
.borrow()
.capabilities()
.contains(&Capability::ColorTransformations)
{
formats.extend([
BufferInfo::Shm {
format: ShmFormat::Abgr2101010,
size: mode,
stride: mode.w as u32 * 4,
},
BufferInfo::Shm {
format: ShmFormat::Xbgr2101010,
size: mode,
stride: mode.w as u32 * 4,
},
]);
}
if let Some(node) = EGLDevice::device_for_display(renderer.egl_context().display())
.ok()
@ -509,6 +549,8 @@ where
let width = data.width as i32;
let height = data.height as i32;
let stride = data.stride as i32;
let format = shm_format_to_fourcc(data.format)
.expect("We should be able to convert all hardcoded shm screencopy formats");
// number of bytes per pixel
// TODO: compute from data.format
@ -517,8 +559,8 @@ where
// ensure consistency, the SHM handler of smithay should ensure this
assert!((offset + (height - 1) * stride + width * pixelsize) as usize <= len);
let mapping =
renderer.copy_framebuffer(Rectangle::from_loc_and_size((0, 0), buffer_size))?;
let mapping = renderer
.copy_framebuffer(Rectangle::from_loc_and_size((0, 0), buffer_size), format)?;
let gl_data = renderer.map_texture(&mapping)?;
assert!((width * height * pixelsize) as usize <= gl_data.len());
@ -613,11 +655,11 @@ pub fn render_output_to_buffer(
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<Gles2Renderbuffer>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
@ -628,7 +670,7 @@ pub fn render_output_to_buffer(
};
if let Ok(dmabuf) = get_dmabuf(buffer) {
render_output::<_, _, Gles2Renderbuffer, Dmabuf>(
render_output::<_, _, GlesRenderbuffer, Dmabuf>(
node,
renderer,
dmabuf,
@ -642,9 +684,14 @@ pub fn render_output_to_buffer(
)
} else {
let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DTError::Rendering)?;
render_output::<_, _, Gles2Renderbuffer, Dmabuf>(
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| DTError::OutputNoMode(OutputNoMode))? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
render_output::<_, _, GlesRenderbuffer, Dmabuf>(
node,
renderer,
render_buffer,
@ -740,11 +787,11 @@ pub fn render_workspace_to_buffer(
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<Gles2Renderbuffer>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
CosmicWindowRenderElement<R>: RenderElement<R>,
@ -754,7 +801,7 @@ pub fn render_workspace_to_buffer(
ScreencopyCursorMode::Captured(_) | ScreencopyCursorMode::None => CursorMode::None,
};
if let Ok(dmabuf) = get_dmabuf(buffer) {
render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>(
render_workspace::<_, _, GlesRenderbuffer, Dmabuf>(
node,
renderer,
dmabuf,
@ -770,9 +817,14 @@ pub fn render_workspace_to_buffer(
)
} else {
let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DTError::Rendering)?;
render_workspace::<_, _, Gles2Renderbuffer, Dmabuf>(
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| DTError::OutputNoMode(OutputNoMode))? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
render_workspace::<_, _, GlesRenderbuffer, Dmabuf>(
node,
renderer,
render_buffer,
@ -881,11 +933,11 @@ pub fn render_window_to_buffer(
+ ImportMem
+ ExportMem
+ Bind<Dmabuf>
+ Offscreen<Gles2Renderbuffer>
+ Offscreen<GlesRenderbuffer>
+ Blit<Dmabuf>
+ AsGlowRenderer,
<R as Renderer>::TextureId: Clone + 'static,
<R as Renderer>::Error: From<Gles2Error>,
<R as Renderer>::Error: From<GlesError>,
CosmicElement<R>: RenderElement<R>,
CosmicMappedRenderElement<R>: RenderElement<R>,
{
@ -942,8 +994,13 @@ pub fn render_window_to_buffer(
renderer.bind(dmabuf).map_err(DTError::Rendering)?;
} else {
let size = buffer_dimensions(buffer).unwrap();
let render_buffer = Offscreen::<Gles2Renderbuffer>::create_buffer(renderer, size)
.map_err(DTError::Rendering)?;
let format =
with_buffer_contents(buffer, |_, _, data| shm_format_to_fourcc(data.format))
.map_err(|_| DTError::OutputNoMode(OutputNoMode))? // eh, we have to do some error
.expect("We should be able to convert all hardcoded shm screencopy formats");
let render_buffer =
Offscreen::<GlesRenderbuffer>::create_buffer(renderer, format, size)
.map_err(DTError::Rendering)?;
renderer.bind(render_buffer).map_err(DTError::Rendering)?;
}