kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

Merge pull request #581 from mahkoh/jorth/mixed-device-use

Browse source 
Fix mixed-device-use error
This commit is contained in:
mahkoh 2025-08-29 13:46:11 +02:00 • committed by GitHub
commit a138525351
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 48 additions and 40 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/backends/metal/transaction.rs
View file

@ -291,8 +291,9 @@ impl MetalDeviceTransaction {
}
*field = plane.obj.id;
}
let render_ctx = slf.dev.dev.backend.ctx.get();
let dev_ctx = slf.dev.dev.ctx.get();
let render_ctx = slf.dev.dev.backend.ctx.get();
let render_ctx = render_ctx.as_ref().unwrap_or(&dev_ctx);
for connector in slf.connectors.values_mut() {
let state = &connector.state;
let dd = &*connector.obj.display.borrow();
@ -463,9 +464,6 @@ impl MetalDeviceTransaction {
if b[0].width != width || b[0].height != height || b[0].format != format {
discard!();
}
let Some(render_ctx) = &render_ctx else {
discard!();
};
if !rc_eq(render_ctx, &b[0].render_ctx) {
discard!();
}
@ -485,6 +483,7 @@ impl MetalDeviceTransaction {
Some(b) => b.clone(),
None => {
let modifiers = &plane.obj.formats.get(&format.drm).unwrap().modifiers;
connector.changed.set(true);
let buffers = slf
.dev
.dev
@ -495,7 +494,7 @@ impl MetalDeviceTransaction {
modifiers,
width,
height,
&slf.dev.dev.ctx.get(),
render_ctx,
plane.obj.ty == PlaneType::Cursor,
)
.map_err(|e| {

6
src/backends/metal/video.rs
View file

@ -2581,12 +2581,12 @@ impl MetalBackend {
plane_modifiers: &IndexSet<Modifier>,
width: i32,
height: i32,
ctx: &Rc<MetalRenderContext>,
render_ctx: &Rc<MetalRenderContext>,
cursor: bool,
) -> Result<[RenderBuffer; N], MetalError> {
let mut blend_buffer = None;
if !cursor {
match ctx.gfx.acquire_blend_buffer(width, height) {
match render_ctx.gfx.acquire_blend_buffer(width, height) {
Ok(bb) => blend_buffer = Some(bb),
Err(e) => {
log::warn!("Could not create blend buffer: {}", ErrorFmt(e));
@ -2601,7 +2601,7 @@ impl MetalBackend {
plane_modifiers,
width,
height,
ctx,
render_ctx,
cursor,
damage_queue.pop().unwrap(),
blend_buffer.clone(),

11
src/gfx_apis/gl.rs
View file

@ -329,7 +329,10 @@ fn fill_boxes3(ctx: &GlRenderContext, boxes: &[[f32; 2]], color: &Color) {
}
fn render_texture(ctx: &GlRenderContext, tex: &CopyTexture) {
let texture = tex.tex.as_gl();
let Some(texture) = tex.tex.as_gl() else {
log::error!("A non-OpenGL texture was passed into OpenGL");
return;
};
if !texture.gl.contents_valid.get() {
log::error!("Ignoring texture with invalid contents");
return;
@ -437,10 +440,8 @@ fn handle_explicit_sync(ctx: &GlRenderContext, img: Option<&Rc<EglImage>>, sync:
}
impl dyn GfxTexture {
fn as_gl(&self) -> &Texture {
(self as &dyn Any)
.downcast_ref()
.expect("Non-gl texture passed into gl")
fn as_gl(&self) -> Option<&Texture> {
(self as &dyn Any).downcast_ref()
}
}

6
src/gfx_apis/vulkan.rs
View file

@ -210,6 +210,10 @@ pub enum VulkanError {
BusyInTransfer,
#[error("Driver does not support descriptor buffers")]
NoDescriptorBuffer,
#[error("A non-vulkan buffer was passed into the vulkan renderer")]
NonVulkanBuffer,
#[error("Mixed vulkan device use")]
MixedVulkanDeviceUse,
}
impl From<VulkanError> for GfxError {
@ -284,7 +288,7 @@ impl GfxContext for Context {
damage: Option<&[Rect]>,
) -> Result<Rc<dyn ShmGfxTexture>, GfxError> {
if let Some(old) = old {
let old = (old as Rc<dyn GfxTexture>).into_vk(&self.0.device.device);
let old = (old as Rc<dyn GfxTexture>).into_vk(&self.0.device.device)?;
let shm = match &old.ty {
VulkanImageMemory::DmaBuf(_) => unreachable!(),
VulkanImageMemory::Blend(_) => unreachable!(),

5
src/gfx_apis/vulkan/image.rs
View file

@ -556,8 +556,9 @@ impl GfxFramebuffer for VulkanImage {
blend_buffer: Option<&Rc<dyn GfxBlendBuffer>>,
blend_cd: &Rc<ColorDescription>,
) -> Result<Option<SyncFile>, GfxError> {
let mut blend_buffer =
blend_buffer.map(|b| b.clone().into_vk(&self.renderer.device.device));
let mut blend_buffer = blend_buffer
.map(|b| b.clone().into_vk(&self.renderer.device.device))
.transpose()?;
if let Some(bb) = &blend_buffer
&& bb.size() != self.size()
{

51
src/gfx_apis/vulkan/renderer.rs
View file

@ -627,7 +627,7 @@ impl VulkanRenderer {
opts: &[GfxApiOpt],
blend_cd: &ColorDescription,
fb_cd: &ColorDescription,
) {
) -> Result<(), VulkanError> {
zone!("convert_ops");
let memory = &mut *self.memory.borrow_mut();
for ops in memory.ops.values_mut() {
@ -744,7 +744,7 @@ impl VulkanRenderer {
}
}
GfxApiOpt::CopyTexture(ct) => {
let tex = ct.tex.clone().into_vk(&self.device.device);
let tex = ct.tex.clone().into_vk(&self.device.device)?;
if tex.contents_are_undefined.get() {
log::warn!("Ignoring undefined texture");
continue;
@ -815,6 +815,7 @@ impl VulkanRenderer {
}
}
sync(memory);
Ok(())
}
fn create_data_buffer(&self) -> Result<(), VulkanError> {
@ -1735,7 +1736,7 @@ impl VulkanRenderer {
clear: Option<&Color>,
region: &Region,
bb: Option<&VulkanImage>,
) {
) -> Result<(), VulkanError> {
zone!("create_paint_regions");
let memory = &mut *self.memory.borrow_mut();
memory.regions_1.clear();
@ -1755,7 +1756,7 @@ impl VulkanRenderer {
break 'opaque false;
}
if !c.opaque {
let tex = c.tex.as_vk(&self.device.device);
let tex = c.tex.as_vk(&self.device.device)?;
if tex.format.has_alpha {
break 'opaque false;
}
@ -1848,6 +1849,7 @@ impl VulkanRenderer {
});
}
}
Ok(())
}
fn elide_blend_buffer(&self, blend_buffer: &mut Option<Rc<VulkanImage>>) {
@ -1874,11 +1876,11 @@ impl VulkanRenderer {
bb_cd: &Rc<ColorDescription>,
) -> Result<(), VulkanError> {
self.check_defunct()?;
self.create_regions(fb, opts, clear, region, blend_buffer.as_deref());
self.create_regions(fb, opts, clear, region, blend_buffer.as_deref())?;
self.elide_blend_buffer(&mut blend_buffer);
let bb = blend_buffer.as_deref();
let buf = self.gfx_command_buffers.allocate()?;
self.convert_ops(opts, bb_cd, fb_cd);
self.convert_ops(opts, bb_cd, fb_cd)?;
self.create_data_buffer()?;
self.create_uniform_buffer()?;
self.collect_memory();
@ -1956,40 +1958,41 @@ impl Debug for VulkanRenderer {
}
impl VulkanImage {
fn assert_device(&self, device: &Device) {
assert_eq!(
self.renderer.device.device.handle(),
device.handle(),
"Mixed vulkan device use"
);
fn assert_device(&self, device: &Device) -> Result<(), VulkanError> {
if self.renderer.device.device.handle() != device.handle() {
return Err(VulkanError::MixedVulkanDeviceUse);
}
Ok(())
}
}
impl dyn GfxTexture {
fn as_vk(&self, device: &Device) -> &VulkanImage {
fn as_vk(&self, device: &Device) -> Result<&VulkanImage, VulkanError> {
let img: &VulkanImage = (self as &dyn Any)
.downcast_ref()
.expect("Non-vulkan texture passed into vulkan");
img.assert_device(device);
img
.ok_or(VulkanError::NonVulkanBuffer)?;
img.assert_device(device)?;
Ok(img)
}
pub(super) fn into_vk(self: Rc<Self>, device: &Device) -> Rc<VulkanImage> {
pub(super) fn into_vk(self: Rc<Self>, device: &Device) -> Result<Rc<VulkanImage>, VulkanError> {
let img: Rc<VulkanImage> = (self as Rc<dyn Any>)
.downcast()
.expect("Non-vulkan texture passed into vulkan");
img.assert_device(device);
img
.ok()
.ok_or(VulkanError::NonVulkanBuffer)?;
img.assert_device(device)?;
Ok(img)
}
}
impl dyn GfxBlendBuffer {
pub(super) fn into_vk(self: Rc<Self>, device: &Device) -> Rc<VulkanImage> {
pub(super) fn into_vk(self: Rc<Self>, device: &Device) -> Result<Rc<VulkanImage>, VulkanError> {
let img: Rc<VulkanImage> = (self as Rc<dyn Any>)
.downcast()
.expect("Non-vulkan blend buffer passed into vulkan");
img.assert_device(device);
img
.ok()
.ok_or(VulkanError::NonVulkanBuffer)?;
img.assert_device(device)?;
Ok(img)
}
}