jay-compositor 1.14.0

The Jay compositor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

pub use vulkan::create_vulkan_allocator;
use {
    crate::{
        async_engine::AsyncEngine,
        backend::DrmDeviceId,
        eventfd_cache::EventfdCache,
        gfx_api::{GfxApi, GfxContext, GfxError},
        io_uring::IoUring,
        pr_caps::PrCapsThread,
        utils::errorfmt::ErrorFmt,
        video::drm::Drm,
    },
    std::rc::Rc,
};

pub mod gl;
mod vulkan;

pub fn create_gfx_context(
    eng: &Rc<AsyncEngine>,
    ring: &Rc<IoUring>,
    eventfd_cache: &Rc<EventfdCache>,
    drm_device_id: Option<DrmDeviceId>,
    drm: &Drm,
    api: GfxApi,
    caps_thread: Option<&PrCapsThread>,
) -> Result<Rc<dyn GfxContext>, GfxError> {
    let mut apis = [GfxApi::OpenGl, GfxApi::Vulkan];
    apis.sort_by_key(|&a| if a == api { -1 } else { a as i32 });
    let mut last_err = None;
    for software in [false, true] {
        for api in apis {
            let res = create_gfx_context_(
                eng,
                ring,
                eventfd_cache,
                drm_device_id,
                drm,
                api,
                caps_thread,
                software,
            );
            match res {
                Ok(_) => {
                    log::info!("Created a {api:?} renderer");
                    if software {
                        log::warn!("Renderer uses software rendering");
                    }
                    return res;
                }
                Err(e) => {
                    log::warn!("Could not create {:?} API: {}", api, ErrorFmt(&e));
                    last_err = Some(e);
                }
            }
        }
    }
    Err(last_err.unwrap())
}

fn create_gfx_context_(
    eng: &Rc<AsyncEngine>,
    ring: &Rc<IoUring>,
    eventfd_cache: &Rc<EventfdCache>,
    drm_device_id: Option<DrmDeviceId>,
    drm: &Drm,
    api: GfxApi,
    caps_thread: Option<&PrCapsThread>,
    software: bool,
) -> Result<Rc<dyn GfxContext>, GfxError> {
    match api {
        GfxApi::OpenGl => gl::create_gfx_context(drm_device_id, drm, software),
        GfxApi::Vulkan => vulkan::create_graphics_context(
            eng,
            ring,
            eventfd_cache,
            drm_device_id,
            drm,
            caps_thread,
            software,
        ),
    }
}