use {
crate::{
allocator::{Allocator, BO_USE_RENDERING, BufferObject, BufferUsage},
cpu_worker::CpuWorker,
format::{Format, XRGB8888},
gfx_api::{
AsyncShmGfxTexture, BufferResvUser, GfxApi, GfxBlendBuffer, GfxContext, GfxError,
GfxFormat, GfxFramebuffer, GfxImage, GfxInternalFramebuffer, GfxTexture, ResetStatus,
ShmGfxTexture,
},
gfx_apis::gl::{
GfxGlState, RenderError, Texture,
egl::{context::EglContext, display::EglDisplay, image::EglImage},
ext::GL_OES_EGL_IMAGE_EXTERNAL,
gl::{
program::GlProgram, render_buffer::GlRenderBuffer, sys::GLint, texture::GlTexture,
},
renderer::{framebuffer::Framebuffer, image::Image},
},
rect::Rect,
video::{
dmabuf::{DmaBuf, DmaBufIds},
drm::{Drm, syncobj::SyncobjCtx},
gbm::GbmDevice,
},
},
ahash::AHashMap,
linearize::{Linearize, StaticMap, static_map},
std::{
cell::{Cell, RefCell},
ffi::CString,
fmt::{Debug, Formatter},
rc::Rc,
},
};
pub(crate) struct TexProg {
pub(crate) prog: GlProgram,
pub(crate) pos: GLint,
pub(crate) texcoord: GLint,
pub(crate) tex: GLint,
pub(crate) alpha: GLint,
}
impl TexProg {
unsafe fn from(prog: GlProgram, alpha_multiplier: bool) -> Self {
unsafe {
let alpha = match alpha_multiplier {
true => prog.get_uniform_location(c"alpha"),
false => 0,
};
Self {
pos: prog.get_attrib_location(c"pos"),
texcoord: prog.get_attrib_location(c"texcoord"),
tex: prog.get_uniform_location(c"tex"),
alpha,
prog,
}
}
}
}
#[derive(Copy, Clone, PartialEq, Linearize)]
pub(in crate::gfx_apis::gl) enum TexCopyType {
Identity,
Multiply,
}
#[derive(Copy, Clone, PartialEq, Linearize)]
pub(in crate::gfx_apis::gl) enum TexSourceType {
Opaque,
HasAlpha,
}
pub(in crate::gfx_apis::gl) struct GlRenderContext {
pub(crate) ctx: Rc<EglContext>,
pub gbm: Rc<GbmDevice>,
pub sync_ctx: Rc<SyncobjCtx>,
pub(crate) render_node: Rc<CString>,
pub(crate) tex_internal: StaticMap<TexCopyType, StaticMap<TexSourceType, TexProg>>,
pub(crate) tex_external: Option<StaticMap<TexCopyType, StaticMap<TexSourceType, TexProg>>>,
pub(crate) fill_prog: GlProgram,
pub(crate) fill_prog_pos: GLint,
pub(crate) fill_prog_color: GLint,
pub(in crate::gfx_apis::gl) gl_state: RefCell<GfxGlState>,
pub(in crate::gfx_apis::gl) buffer_resv_user: BufferResvUser,
}
impl Debug for GlRenderContext {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RenderContext").finish_non_exhaustive()
}
}
impl GlRenderContext {
pub fn reset_status(&self) -> Option<ResetStatus> {
self.ctx.reset_status()
}
pub(in crate::gfx_apis::gl) fn from_drm_device(
drm: &Drm,
software: bool,
) -> Result<Self, RenderError> {
let node = drm
.get_render_node()?
.ok_or(RenderError::NoRenderNode)
.map(Rc::new)?;
let dpy = EglDisplay::create(drm, software)?;
if !dpy.formats.contains_key(&XRGB8888.drm) {
return Err(RenderError::XRGB888);
}
let ctx = dpy.create_context()?;
ctx.with_current(|| unsafe { Self::new(&ctx, &node) })
}
unsafe fn new(ctx: &Rc<EglContext>, node: &Rc<CString>) -> Result<Self, RenderError> {
let tex_vert = include_str!("../shaders/tex.vert.glsl");
let tex_frag = include_str!("../shaders/tex.frag.glsl");
let create_programs = |external: bool| {
let create_program = |alpha_multiplier: bool, alpha: bool| {
let mut tex_frac_src = String::new();
if external {
tex_frac_src.push_str("#define EXTERNAL\n");
}
if alpha_multiplier {
tex_frac_src.push_str("#define ALPHA_MULTIPLIER\n");
}
if alpha {
tex_frac_src.push_str("#define ALPHA\n");
}
tex_frac_src.push_str(tex_frag);
unsafe {
let prog = GlProgram::from_shaders(ctx, tex_vert, &tex_frac_src)?;
Ok::<_, RenderError>(TexProg::from(prog, alpha_multiplier))
}
};
Ok::<_, RenderError>(static_map! {
TexCopyType::Identity => static_map! {
TexSourceType::Opaque => create_program(false, false)?,
TexSourceType::HasAlpha => create_program(false, true)?,
},
TexCopyType::Multiply => static_map! {
TexSourceType::Opaque => create_program(true, false)?,
TexSourceType::HasAlpha => create_program(true, true)?,
},
})
};
let tex_internal = create_programs(false)?;
let tex_external = if ctx.ext.contains(GL_OES_EGL_IMAGE_EXTERNAL) {
Some(create_programs(true)?)
} else {
None
};
let fill_prog = unsafe {
GlProgram::from_shaders(
ctx,
include_str!("../shaders/fill.vert.glsl"),
include_str!("../shaders/fill.frag.glsl"),
)?
};
Ok(Self {
ctx: ctx.clone(),
gbm: ctx.dpy.gbm.clone(),
sync_ctx: Rc::new(SyncobjCtx::new(ctx.dpy.gbm.drm.fd())),
render_node: node.clone(),
tex_internal,
tex_external,
fill_prog_pos: unsafe { fill_prog.get_attrib_location(c"pos") },
fill_prog_color: unsafe { fill_prog.get_uniform_location(c"color") },
fill_prog,
gl_state: Default::default(),
buffer_resv_user: Default::default(),
})
}
pub fn render_node(&self) -> Rc<CString> {
self.render_node.clone()
}
pub fn formats(&self) -> &Rc<AHashMap<u32, GfxFormat>> {
&self.ctx.formats
}
fn dmabuf_fb(self: &Rc<Self>, buf: &DmaBuf) -> Result<Rc<Framebuffer>, RenderError> {
self.ctx.with_current(|| unsafe {
let img = self.ctx.dpy.import_dmabuf(buf)?;
let rb = GlRenderBuffer::from_image(&img, &self.ctx)?;
let fb = rb.create_framebuffer()?;
Ok(Rc::new(Framebuffer {
ctx: self.clone(),
gl: fb,
}))
})
}
fn dmabuf_img(self: &Rc<Self>, buf: &DmaBuf) -> Result<Rc<Image>, RenderError> {
self.dmabuf_img2(buf, None)
}
fn dmabuf_img2(
self: &Rc<Self>,
buf: &DmaBuf,
bo: Option<Rc<dyn BufferObject>>,
) -> Result<Rc<Image>, RenderError> {
self.ctx.with_current(|| {
let img = self.ctx.dpy.import_dmabuf(buf)?;
Ok(Rc::new(Image {
ctx: self.clone(),
gl: img,
_bo: bo,
}))
})
}
fn shmem_texture(
self: &Rc<Self>,
data: &[Cell<u8>],
format: &'static Format,
width: i32,
height: i32,
stride: i32,
) -> Result<Rc<Texture>, RenderError> {
let gl = GlTexture::import_shm(&self.ctx, data, format, width, height, stride)?;
Ok(Rc::new(Texture {
ctx: self.clone(),
gl,
format,
}))
}
pub fn image_to_fb(
self: &Rc<Self>,
img: &Rc<EglImage>,
) -> Result<Rc<Framebuffer>, RenderError> {
self.ctx.with_current(|| unsafe {
let rb = GlRenderBuffer::from_image(img, &self.ctx)?;
let fb = rb.create_framebuffer()?;
Ok(Rc::new(Framebuffer {
ctx: self.clone(),
gl: fb,
}))
})
}
}
impl GfxContext for GlRenderContext {
fn reset_status(&self) -> Option<ResetStatus> {
self.reset_status()
}
fn render_node(&self) -> Option<Rc<CString>> {
Some(self.render_node())
}
fn formats(&self) -> &Rc<AHashMap<u32, GfxFormat>> {
self.formats()
}
fn fast_ram_access(&self) -> bool {
self.ctx.dpy.fast_ram_access
}
fn dmabuf_fb(self: Rc<Self>, buf: &DmaBuf) -> Result<Rc<dyn GfxFramebuffer>, GfxError> {
(&self)
.dmabuf_fb(buf)
.map(|w| w as Rc<dyn GfxFramebuffer>)
.map_err(|e| e.into())
}
fn dmabuf_img(self: Rc<Self>, buf: &DmaBuf) -> Result<Rc<dyn GfxImage>, GfxError> {
(&self)
.dmabuf_img(buf)
.map(|w| w as Rc<dyn GfxImage>)
.map_err(|e| e.into())
}
fn shmem_texture(
self: Rc<Self>,
_old: Option<Rc<dyn ShmGfxTexture>>,
data: &[Cell<u8>],
format: &'static Format,
width: i32,
height: i32,
stride: i32,
_damage: Option<&[Rect]>,
) -> Result<Rc<dyn ShmGfxTexture>, GfxError> {
(&self)
.shmem_texture(data, format, width, height, stride)
.map(|w| w as Rc<dyn ShmGfxTexture>)
.map_err(|e| e.into())
}
fn async_shmem_texture(
self: Rc<Self>,
format: &'static Format,
width: i32,
height: i32,
stride: i32,
_cpu_worker: &Rc<CpuWorker>,
) -> Result<Rc<dyn AsyncShmGfxTexture>, GfxError> {
let tex = self.ctx.with_current(|| unsafe {
let mut tex = 0;
(self.ctx.dpy.gles.glGenTextures)(1, &mut tex);
Ok(tex)
})?;
Ok(Rc::new(Texture {
gl: GlTexture {
ctx: self.ctx.clone(),
img: None,
tex,
width,
height,
stride,
external_only: false,
format,
contents_valid: Cell::new(false),
},
ctx: self,
format,
}))
}
fn allocator(&self) -> Rc<dyn Allocator> {
self.gbm.clone()
}
fn gfx_api(&self) -> GfxApi {
GfxApi::OpenGl
}
fn create_internal_fb(
self: Rc<Self>,
_cpu_worker: &Rc<CpuWorker>,
width: i32,
height: i32,
stride: i32,
format: &'static Format,
) -> Result<Rc<dyn GfxInternalFramebuffer>, GfxError> {
let fb = self.ctx.with_current(|| unsafe {
GlRenderBuffer::new(&self.ctx, width, height, stride, format)?.create_framebuffer()
})?;
Ok(Rc::new(Framebuffer { ctx: self, gl: fb }))
}
fn create_read_write_img(
self: Rc<Self>,
dma_buf_ids: &DmaBufIds,
width: i32,
height: i32,
format: &'static Format,
) -> Result<(Rc<dyn GfxFramebuffer>, Rc<dyn GfxTexture>), GfxError> {
let allocator = self.allocator();
let Some(format) = self.formats().get(&format.drm) else {
return Err(RenderError::UnsupportedFormat.into());
};
let mut needs_render_usage = false;
let mut modifiers = vec![];
for (modifier, gwm) in format.write_modifiers.iter() {
if format.read_modifiers.contains(modifier) {
needs_render_usage |= gwm.needs_render_usage;
modifiers.push(*modifier);
}
}
let mut usage = BufferUsage::none();
if needs_render_usage {
usage |= BO_USE_RENDERING;
}
let bo = allocator
.create_bo(dma_buf_ids, width, height, format.format, &modifiers, usage)
.map_err(RenderError::AllocateBo)?;
let img = self.dmabuf_img2(bo.dmabuf(), Some(bo.clone()))?;
let tex = img.clone().to_texture()?;
let fb = img.to_framebuffer()?;
Ok((fb, tex))
}
fn syncobj_ctx(&self) -> Option<&Rc<SyncobjCtx>> {
Some(&self.sync_ctx)
}
fn acquire_blend_buffer(
&self,
_width: i32,
_height: i32,
) -> Result<Rc<dyn GfxBlendBuffer>, GfxError> {
Err(GfxError(Box::new(RenderError::NoBlendBuffer)))
}
fn supports_invalid_modifier(&self) -> bool {
true
}
}