monolith

use crate::Error;

use crate::device::Shared;

use crate::dmabuf::{self, DmabufCaps, RENDER_USAGE, SAMPLE_USAGE, VulkanAllocator};

use crate::format::{BYTES_PER_PIXEL, SUPPORTED};

use crate::frame::{Op, VulkanFrame};

use crate::image::{

    ImageInner, Staging, VulkanImage, VulkanMapping, VulkanTarget, VulkanTexture, color_range,

};

use crate::pipeline::Pipelines;

use crate::sync::{FenceInner, VkFence};

use ash::vk;

use gpu_allocator::MemoryLocation;

use smithay::backend::allocator::Fourcc;

use smithay::backend::allocator::dmabuf::{Dmabuf, WeakDmabuf};

use smithay::backend::allocator::format::FormatSet;

use smithay::backend::renderer::ImportMemWl;

use smithay::backend::renderer::sync::SyncPoint;

use smithay::backend::renderer::{

    Bind, ContextId, DebugFlags, ExportMem, ImportDma, ImportDmaWl, ImportMem, Offscreen, Renderer,

    RendererSuper, Texture, TextureFilter,

};

use smithay::reexports::wayland_server::Resource;

use smithay::reexports::wayland_server::backend::ObjectId;

use smithay::reexports::wayland_server::protocol::wl_buffer::WlBuffer;

use smithay::utils::{Buffer, Physical, Rectangle, Size, Transform};

use smithay::wayland::compositor::SurfaceData;

use smithay::wayland::shm::{shm_format_to_fourcc, with_buffer_contents};

use std::cell::Cell;

use std::collections::HashMap;

use std::fmt;

use std::marker::PhantomData;

use std::sync::{Arc, Mutex};

use std::time::{Duration, Instant};

struct Pending {

    fence: Arc<FenceInner>,

    cmd: vk::CommandBuffer,

    _keep: Vec<Arc<ImageInner>>,

    _staging: Option<Staging>,

}

pub struct VulkanRenderer {

    pending: Vec<Pending>,

    dmabuf_textures: HashMap<WeakDmabuf, VulkanTexture>,

    dmabuf_targets: HashMap<WeakDmabuf, Arc<ImageInner>>,

    pipelines: Pipelines,

    pool: vk::CommandPool,

    /// Command buffers whose work finished, reset and reused by `begin`.

    spare_cmds: Vec<vk::CommandBuffer>,

    samplers: [vk::Sampler; 4],

    min_filter: TextureFilter,

    mag_filter: TextureFilter,

    debug: DebugFlags,

    context: ContextId<VulkanTexture>,

    caps: Arc<DmabufCaps>,

    shared: Arc<Shared>,

    submissions: Cell<u64>,

    /// Shm uploads staged off the main thread, by buffer.

    staged: HashMap<ObjectId, (WlBuffer, StagedShm)>,

    stall: Cell<StallPhase>,

}

/// Where in every 1024 submissions the driver stalls. A phase is trusted

/// once two stalls land on it.

#[derive(Clone, Copy, Default)]

struct StallPhase {

    phase: Option<u64>,

    seen: Option<u64>,

}

impl StallPhase {

    fn saw(self, at: u64) -> Self {

        if self.seen == Some(at) {

            if self.phase != Some(at) {

                tracing::debug!(phase = at, "queue submissions stall periodically");

            }

            Self {

                phase: Some(at),

                seen: Some(at),

            }

        } else {

            Self {

                seen: Some(at),

                ..self

            }

        }

    }

}

/// A submission this slow is a driver stall rather than work.

const STALL: Duration = Duration::from_micros(1500);

/// How many submissions early a stall is absorbed. Each empty one costs

/// tens of microseconds.

const ABSORB_AHEAD: u64 = 8;

impl fmt::Debug for VulkanRenderer {

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        f.debug_struct("VulkanRenderer")

            .field("device", &self.shared.device.name)

            .finish()

    }

}

impl VulkanRenderer {

    pub fn new() -> Result<Self, Error> {

        Self::with_node(None)

    }

    /// A renderer on the GPU behind DRM device number `node`, so it can

    /// render into buffers that GPU scans out.

    pub fn for_node(node: u64) -> Result<Self, Error> {

        Self::with_node(Some(node))

    }

    fn with_node(node: Option<u64>) -> Result<Self, Error> {

        let shared = Arc::new(Shared::new(node)?);

        let d = &shared.device.device;

        let pool = unsafe {

            d.create_command_pool(

                &vk::CommandPoolCreateInfo::default()

                    .queue_family_index(shared.device.queue_family)

                    .flags(

                        vk::CommandPoolCreateFlags::TRANSIENT

                            | vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER,

                    ),

                None,

            )?

        };

        let filter = |f: TextureFilter| match f {

            TextureFilter::Linear => vk::Filter::LINEAR,

            TextureFilter::Nearest => vk::Filter::NEAREST,

        };

        let mut samplers = [vk::Sampler::null(); 4];

        for (i, s) in samplers.iter_mut().enumerate() {

            let (min, mag) = (sampler_filter(i >> 1), sampler_filter(i & 1));

            *s = unsafe {

                d.create_sampler(

                    &vk::SamplerCreateInfo::default()

                        .min_filter(filter(min))

                        .mag_filter(filter(mag))

                        .address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)

                        .address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)

                        .address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE),

                    None,

                )?

            };

        }

        Ok(Self {

            pending: Vec::new(),

            dmabuf_textures: HashMap::new(),

            dmabuf_targets: HashMap::new(),

            pipelines: Pipelines::new(&shared)?,

            pool,

            spare_cmds: Vec::new(),

            submissions: Cell::new(0),

            staged: HashMap::new(),

            stall: Cell::new(StallPhase {

                // Measured on an RTX 3060, see research/nvidia.md.

                phase: shared.device.name.contains("NVIDIA").then_some(1015),

                seen: None,

            }),

            samplers,

            min_filter: TextureFilter::Linear,

            mag_filter: TextureFilter::Linear,

            debug: DebugFlags::empty(),

            context: ContextId::new(),

            caps: Arc::new(DmabufCaps::query(&shared)),

            shared,

        })

    }

    /// Name of the physical device in use.

    pub fn device_name(&self) -> &str {

        &self.shared.device.name

    }

    /// Whether dmabufs can be imported, rendered into and allocated.

    pub fn supports_dmabuf(&self) -> bool {

        self.caps.render.iter().next().is_some()

    }

    /// Formats and modifiers this renderer can render into as dmabufs.

    pub fn render_formats(&self) -> FormatSet {

        self.caps.render.clone()

    }

    /// An allocator for render-capable dmabufs on this device.

    pub fn allocator(&self) -> VulkanAllocator {

        VulkanAllocator {

            shared: self.shared.clone(),

            caps: self.caps.clone(),

        }

    }

    pub(crate) fn shared(&self) -> &Arc<Shared> {

        &self.shared

    }

    pub(crate) fn context_id_ref(&self) -> &ContextId<VulkanTexture> {

        &self.context

    }

    fn sampler(&self) -> vk::Sampler {

        let idx = |f: TextureFilter| usize::from(f == TextureFilter::Nearest);

        self.samplers[(idx(self.min_filter) << 1) | idx(self.mag_filter)]

    }

    fn reap(&mut self) {

        let spare = &mut self.spare_cmds;

        self.pending.retain(|p| {

            if !p.fence.signaled() {

                return true;

            }

            spare.push(p.cmd);

            false

        });

        self.dmabuf_textures.retain(|k, _| !k.is_gone());

        self.dmabuf_targets.retain(|k, _| !k.is_gone());

    }

    fn begin(&mut self) -> Result<vk::CommandBuffer, Error> {

        let d = &self.shared.device.device;

        let cmd = match self.spare_cmds.pop() {

            Some(cmd) => {

                unsafe { d.reset_command_buffer(cmd, vk::CommandBufferResetFlags::empty())? };

                cmd

            }

            None => unsafe {

                d.allocate_command_buffers(

                    &vk::CommandBufferAllocateInfo::default()

                        .command_pool(self.pool)

                        .level(vk::CommandBufferLevel::PRIMARY)

                        .command_buffer_count(1),

                )?[0]

            },

        };

        unsafe {

            d.begin_command_buffer(

                cmd,

                &vk::CommandBufferBeginInfo::default()

                    .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT),

            )?

        };

        Ok(cmd)

    }

    #[profiling::function]

    fn end_and_submit(&self, cmd: vk::CommandBuffer) -> Result<Arc<FenceInner>, Error> {

        let d = &self.shared.device.device;

        {

            profiling::scope!("end_command_buffer");

            unsafe { d.end_command_buffer(cmd)? };

        }

        let fence = {

            profiling::scope!("create_fence");

            FenceInner::new(&self.shared)?

        };

        let cmds = [vk::CommandBufferSubmitInfo::default().command_buffer(cmd)];

        let submit = vk::SubmitInfo2::default().command_buffer_infos(&cmds);

        let queue = self

            .shared

            .device

            .queue

            .lock()

            .unwrap_or_else(|e| e.into_inner());

        let began = Instant::now();

        {

            profiling::scope!("queue_submit");

            unsafe { d.queue_submit2(*queue, &[submit], fence.fence())? };

        }

        let n = self.submissions.get();

        self.submissions.set(n + 1);

        if began.elapsed() > STALL {

            self.stall.set(self.stall.get().saw(n % 1024));

        }

        Ok(fence)

    }

    /// Spends an upcoming stalling submission on empty command buffers, so

    /// the stall lands now, in idle time, instead of in a frame. Call it

    /// right after a flip. NVIDIA stalls for milliseconds on every 1024th

    /// submission, see research/nvidia.md.

    pub fn absorb_submit_stall(&mut self) -> Result<(), Error> {

        self.reap();

        let Some(phase) = self.stall.get().phase else {

            return Ok(());

        };

        let ahead = (phase + 1024 - self.submissions.get() % 1024) % 1024;

        if ahead >= ABSORB_AHEAD {

            return Ok(());

        }

        for _ in 0..=ahead {

            let cmd = self.begin()?;

            let fence = self.end_and_submit(cmd)?;

            self.pending.push(Pending {

                fence,

                cmd,

                _keep: Vec::new(),

                _staging: None,

            });

        }

        Ok(())

    }

    /// Records, submits and waits for a short command buffer.

    fn one_shot(

        &mut self,

        record: impl FnOnce(&ash::Device, vk::CommandBuffer, u32),

    ) -> Result<(), Error> {

        let cmd = self.begin()?;

        record(

            &self.shared.device.device,

            cmd,

            self.shared.device.queue_family,

        );

        let fence = self.end_and_submit(cmd)?;

        let res = fence.wait();

        self.spare_cmds.push(cmd);

        Ok(res?)

    }

    #[profiling::function]

    pub(crate) fn submit(

        &mut self,

        target: &mut VulkanTarget<'_>,

        ops: Vec<Op>,

    ) -> Result<SyncPoint, Error> {

        self.reap();

        let image = target.0.clone();

        let mut sampled: Vec<Arc<ImageInner>> = Vec::new();

        for op in &ops {

            if let Op::Draw {

                texture: Some(t), ..

            } = op

                && !sampled.iter().any(|s| Arc::ptr_eq(s, &t.0))

            {

                sampled.push(t.0.clone());

            }

        }

        let mut pipelines = Vec::with_capacity(ops.len());

        for op in &ops {

            pipelines.push(match op {

                Op::Draw { kind, .. } => Some(self.pipelines.get(image.format, *kind)?),

                Op::Clear { .. } => None,

            });

        }

        let cmd = self.begin()?;

        let d = &self.shared.device.device;

        let family = self.shared.device.queue_family;

        let push = &self.shared.device.push_descriptor;

        let (w, h) = (image.width, image.height);

        let sampler = self.sampler();

        unsafe {

            for t in &sampled {

                acquire(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);

            }

            acquire(

                d,

                cmd,

                family,

                &image,

                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,

            );

            let attachments = [vk::RenderingAttachmentInfo::default()

                .image_view(image.view)

                .image_layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL)

                .load_op(vk::AttachmentLoadOp::LOAD)

                .store_op(vk::AttachmentStoreOp::STORE)];

            let area = vk::Rect2D {

                offset: vk::Offset2D::default(),

                extent: vk::Extent2D {

                    width: w,

                    height: h,

                },

            };

            d.cmd_begin_rendering(

                cmd,

                &vk::RenderingInfo::default()

                    .render_area(area)

                    .layer_count(1)

                    .color_attachments(&attachments),

            );

            d.cmd_set_viewport(

                cmd,

                0,

                &[vk::Viewport {

                    x: 0.0,

                    y: 0.0,

                    width: w as f32,

                    height: h as f32,

                    min_depth: 0.0,

                    max_depth: 1.0,

                }],

            );

            let mut bound = vk::Pipeline::null();

            for (op, pipeline) in ops.iter().zip(pipelines) {

                match op {

                    Op::Clear { color, rects } => {

                        let clear = [vk::ClearAttachment {

                            aspect_mask: vk::ImageAspectFlags::COLOR,

                            color_attachment: 0,

                            clear_value: vk::ClearValue {

                                color: vk::ClearColorValue { float32: *color },

                            },

                        }];

                        let rects: Vec<_> = rects

                            .iter()

                            .map(|&rect| vk::ClearRect {

                                rect,

                                base_array_layer: 0,

                                layer_count: 1,

                            })

                            .collect();

                        d.cmd_clear_attachments(cmd, &clear, &rects);

                    }

                    Op::Draw {

                        texture,

                        push: constants,

                        scissors,

                        ..

                    } => {

                        let pipeline = pipeline.unwrap_or_default();

                        if pipeline != bound {

                            d.cmd_bind_pipeline(cmd, vk::PipelineBindPoint::GRAPHICS, pipeline);

                            bound = pipeline;

                        }

                        if let Some(t) = texture {

                            let info = [vk::DescriptorImageInfo::default()

                                .image_view(t.0.view)

                                .image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)

                                .sampler(sampler)];

                            let write = vk::WriteDescriptorSet::default()

                                .dst_binding(0)

                                .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)

                                .image_info(&info);

                            push.cmd_push_descriptor_set(

                                cmd,

                                vk::PipelineBindPoint::GRAPHICS,

                                self.pipelines.layout,

                                0,

                                &[write],

                            );

                        }

                        d.cmd_push_constants(

                            cmd,

                            self.pipelines.layout,

                            vk::ShaderStageFlags::VERTEX | vk::ShaderStageFlags::FRAGMENT,

                            0,

                            constants.bytes(),

                        );

                        for s in scissors {

                            d.cmd_set_scissor(cmd, 0, &[*s]);

                            d.cmd_draw(cmd, 4, 1, 0, 0);

                        }

                    }

                }

            }

            d.cmd_end_rendering(cmd);

            release(

                d,

                cmd,

                family,

                &image,

                vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,

            );

            for t in &sampled {

                release(d, cmd, family, t, vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);

            }

        }

        let fence = self.end_and_submit(cmd)?;

        sampled.push(image);

        self.pending.push(Pending {

            fence: fence.clone(),

            cmd,

            _keep: sampled,

            _staging: None,

        });

        Ok(SyncPoint::from(VkFence(fence)))

    }

    /// Copies `region` of a full-image `data` into `image`, rows top-down or

    /// flipped.

    fn upload(

        &mut self,

        image: &Arc<ImageInner>,

        data: &[u8],

        region: Rectangle<i32, Buffer>,

        flipped: bool,

    ) -> Result<(), Error> {

        let width = image.width as usize;

        let rows = image.height as usize;

        let needed = width * rows * BYTES_PER_PIXEL;

        if data.len() < needed {

            return Err(Error::BufferTooSmall {

                needed,

                got: data.len(),

            });

        }

        let stride = width * BYTES_PER_PIXEL;

        self.upload_with(image, region, |y| {

            let from = if flipped { rows - 1 - y } else { y };

            let start = from * stride + region.loc.x as usize * BYTES_PER_PIXEL;

            &data[start..start + region.size.w as usize * BYTES_PER_PIXEL]

        })

    }

    /// Uploads `region` of `image`, taking each image row `y` in the region

    /// from `row(y)`. The CPU does not wait: the copy is ordered before later

    /// frames by its barrier, and its staging memory lives until its fence.

    #[profiling::function]

    fn upload_with<'a>(

        &mut self,

        image: &Arc<ImageInner>,

        region: Rectangle<i32, Buffer>,

        row: impl Fn(usize) -> &'a [u8],

    ) -> Result<(), Error> {

        if image.external {

            return Err(Error::ForeignTexture);

        }

        self.reap();

        if region.size.w <= 0 || region.size.h <= 0 {

            return Ok(());

        }

        let staging = stage_rows(&self.shared, region, row)?;

        self.copy_staged(image, region, staging)

    }

    /// Copies staged pixels into `region` of `image` on the GPU.

    fn copy_staged(

        &mut self,

        image: &Arc<ImageInner>,

        region: Rectangle<i32, Buffer>,

        staging: Staging,

    ) -> Result<(), Error> {

        let (w, h) = (region.size.w as usize, region.size.h as usize);

        let copy = vk::BufferImageCopy::default()

            .buffer_row_length(w as u32)

            .image_subresource(

                vk::ImageSubresourceLayers::default()

                    .aspect_mask(vk::ImageAspectFlags::COLOR)

                    .layer_count(1),

            )

            .image_offset(vk::Offset3D {

                x: region.loc.x,

                y: region.loc.y,

                z: 0,

            })

            .image_extent(vk::Extent3D {

                width: w as u32,

                height: h as u32,

                depth: 1,

            });

        let cmd = self.begin()?;

        let d = &self.shared.device.device;

        let family = self.shared.device.queue_family;

        unsafe {

            acquire(d, cmd, family, image, vk::ImageLayout::TRANSFER_DST_OPTIMAL);

            d.cmd_copy_buffer_to_image(

                cmd,

                staging.buffer,

                image.image,

                vk::ImageLayout::TRANSFER_DST_OPTIMAL,

                &[copy],

            );

            acquire(

                d,

                cmd,

                family,

                image,

                vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,

            );

        }

        let fence = self.end_and_submit(cmd)?;

        self.pending.push(Pending {

            fence,

            cmd,

            _keep: vec![image.clone()],

            _staging: Some(staging),

        });

        Ok(())

    }

    fn read_back(

        &mut self,

        image: &Arc<ImageInner>,

        region: Rectangle<i32, Buffer>,

        fourcc: Fourcc,

    ) -> Result<VulkanMapping, Error> {

        let region = region

            .intersection(Rectangle::from_size(

                (image.width as i32, image.height as i32).into(),

            ))

            .unwrap_or_default();

        let (w, h) = (region.size.w.max(0) as u32, region.size.h.max(0) as u32);

        let swap = needs_swizzle(image.fourcc, fourcc)?;

        let len = (w as usize * h as usize * BYTES_PER_PIXEL).max(BYTES_PER_PIXEL);

        let staging = Staging::new(

            &self.shared,

            len,

            vk::BufferUsageFlags::TRANSFER_DST,

            MemoryLocation::GpuToCpu,

        )?;

        if w > 0 && h > 0 {

            let copy = vk::BufferImageCopy::default()

                .image_subresource(

                    vk::ImageSubresourceLayers::default()

                        .aspect_mask(vk::ImageAspectFlags::COLOR)

                        .layer_count(1),

                )

                .image_offset(vk::Offset3D {

                    x: region.loc.x,

                    y: region.loc.y,

                    z: 0,

                })

                .image_extent(vk::Extent3D {

                    width: w,

                    height: h,

                    depth: 1,

                });

            let buffer = staging.buffer;

            let source = image.clone();

            self.one_shot(|d, cmd, family| unsafe {

                acquire(

                    d,

                    cmd,

                    family,

                    &source,

                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,

                );

                d.cmd_copy_image_to_buffer(

                    cmd,

                    source.image,

                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,

                    buffer,

                    &[copy],

                );

                release(

                    d,

                    cmd,

                    family,

                    &source,

                    vk::ImageLayout::TRANSFER_SRC_OPTIMAL,

                );

            })?;

        }

        let mut data = staging.bytes()[..w as usize * h as usize * BYTES_PER_PIXEL].to_vec();

        if swap {

            for px in data.as_chunks_mut::<BYTES_PER_PIXEL>().0 {

                px.swap(0, 2);

            }

        }

        Ok(VulkanMapping {

            data,

            width: w,

            height: h,

            fourcc,

        })

    }

    fn own(&self, image: &Arc<ImageInner>) -> Result<(), Error> {

        if Arc::ptr_eq(&image.shared, &self.shared) {

            Ok(())

        } else {

            Err(Error::ForeignTexture)

        }

    }

}

impl Drop for VulkanRenderer {

    fn drop(&mut self) {

        let d = &self.shared.device.device;

        unsafe {

            let _ = d.device_wait_idle();

            for p in self.pending.drain(..) {

                d.free_command_buffers(self.pool, &[p.cmd]);

            }

            for s in self.samplers {

                d.destroy_sampler(s, None);

            }

            d.destroy_command_pool(self.pool, None);

        }

    }

}

fn sampler_filter(bit: usize) -> TextureFilter {

    if bit == 0 {

        TextureFilter::Linear

    } else {

        TextureFilter::Nearest

    }

}

/// A full barrier between all earlier and later work on the image, optionally

/// transferring ownership between queue families. Coarse, but correct for

/// every transition the renderer makes.

unsafe fn barrier(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    image: vk::Image,

    old: vk::ImageLayout,

    new: vk::ImageLayout,

    src_family: u32,

    dst_family: u32,

) {

    let b = [vk::ImageMemoryBarrier2::default()

        .src_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)

        .src_access_mask(vk::AccessFlags2::MEMORY_WRITE)

        .dst_stage_mask(vk::PipelineStageFlags2::ALL_COMMANDS)

        .dst_access_mask(vk::AccessFlags2::MEMORY_READ | vk::AccessFlags2::MEMORY_WRITE)

        .old_layout(old)

        .new_layout(new)

        .src_queue_family_index(src_family)

        .dst_queue_family_index(dst_family)

        .image(image)

        .subresource_range(color_range())];

    unsafe {

        d.cmd_pipeline_barrier2(

            cmd,

            &vk::DependencyInfo::default().image_memory_barriers(&b),

        )

    };

}

/// Moves an image into `layout` for use on this queue. Dmabuf images come

/// from the foreign queue family in the general layout, others continue from

/// their tracked layout.

unsafe fn acquire(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    family: u32,

    image: &ImageInner,

    layout: vk::ImageLayout,

) {

    if image.external {

        unsafe {

            barrier(

                d,

                cmd,

                image.image,

                vk::ImageLayout::GENERAL,

                layout,

                vk::QUEUE_FAMILY_FOREIGN_EXT,

                family,

            )

        };

    } else {

        let old = image.layout();

        if old != layout {

            unsafe {

                barrier(

                    d,

                    cmd,

                    image.image,

                    old,

                    layout,

                    vk::QUEUE_FAMILY_IGNORED,

                    vk::QUEUE_FAMILY_IGNORED,

                )

            };

            image.set_layout(layout);

        }

    }

}

/// Hands a dmabuf image back to the foreign queue family after use.

unsafe fn release(

    d: &ash::Device,

    cmd: vk::CommandBuffer,

    family: u32,

    image: &ImageInner,

    layout: vk::ImageLayout,

) {

    if image.external {

        unsafe {

            barrier(

                d,

                cmd,

                image.image,

                layout,

                vk::ImageLayout::GENERAL,

                family,

                vk::QUEUE_FAMILY_FOREIGN_EXT,

            )

        };

    }

}

/// Whether reading `from` as `to` needs red and blue swapped.

fn needs_swizzle(from: Fourcc, to: Fourcc) -> Result<bool, Error> {

    let bgr = |f: Fourcc| match f {

        Fourcc::Argb8888 | Fourcc::Xrgb8888 => Ok(true),

        Fourcc::Abgr8888 | Fourcc::Xbgr8888 => Ok(false),

        f => Err(Error::UnsupportedFormat(f)),

    };

    Ok(bgr(from)? != bgr(to)?)

}

impl RendererSuper for VulkanRenderer {

    type Error = Error;

    type TextureId = VulkanTexture;

    type Framebuffer<'buffer> = VulkanTarget<'buffer>;

    type Frame<'frame, 'buffer>

        = VulkanFrame<'frame, 'buffer>

    where

        'buffer: 'frame,

        Self: 'frame;

}

impl Renderer for VulkanRenderer {

    fn context_id(&self) -> ContextId<VulkanTexture> {

        self.context.clone()

    }

    fn downscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {

        self.min_filter = filter;

        Ok(())

    }

    fn upscale_filter(&mut self, filter: TextureFilter) -> Result<(), Error> {

        self.mag_filter = filter;

        Ok(())

    }

    fn set_debug_flags(&mut self, flags: DebugFlags) {

        self.debug = flags;

    }

    fn debug_flags(&self) -> DebugFlags {

        self.debug

    }

    fn render<'frame, 'buffer>(

        &'frame mut self,

        framebuffer: &'frame mut VulkanTarget<'buffer>,

        output_size: Size<i32, Physical>,

        dst_transform: Transform,

    ) -> Result<VulkanFrame<'frame, 'buffer>, Error>

    where

        'buffer: 'frame,

    {

        self.own(&framebuffer.0)?;

        self.reap();

        Ok(VulkanFrame::new(

            self,

            framebuffer,

            output_size,

            dst_transform,

        ))

    }

    fn wait(&mut self, sync: &SyncPoint) -> Result<(), Error> {

        sync.wait().map_err(|_| Error::Interrupted)

    }

    fn cleanup_texture_cache(&mut self) -> Result<(), Error> {

        self.reap();

        Ok(())

    }

    fn invalidate_caches(&mut self) -> Result<(), Error> {