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