render: split module into gfx_apis and renderer

src/gfx_apis/gl/egl/context.rs

@@ -0,0 +1,96 @@
+use {
+    crate::gfx_apis::gl::{
+        egl::{
+            display::EglDisplay,
+            sys::{eglDestroyContext, eglMakeCurrent, EGLContext, EGLSurface, EGL_FALSE, EGL_TRUE},
+            PROCS,
+        },
+        ext::{DisplayExt, GlExt},
+        sys::{
+            GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB,
+            GL_UNKNOWN_CONTEXT_RESET_ARB,
+        },
+        RenderError, ResetStatus,
+    },
+    std::rc::Rc,
+};
+
+#[derive(Debug, Clone)]
+pub struct EglContext {
+    pub dpy: Rc<EglDisplay>,
+    pub ext: GlExt,
+    pub ctx: EGLContext,
+}
+
+impl Drop for EglContext {
+    fn drop(&mut self) {
+        unsafe {
+            if eglDestroyContext(self.dpy.dpy, self.ctx) != EGL_TRUE {
+                log::warn!("`eglDestroyContext` failed");
+            }
+        }
+    }
+}
+
+#[thread_local]
+static mut CURRENT: EGLContext = EGLContext::none();
+
+impl EglContext {
+    pub fn reset_status(&self) -> Option<ResetStatus> {
+        if !self
+            .dpy
+            .exts
+            .contains(DisplayExt::EXT_CREATE_CONTEXT_ROBUSTNESS)
+        {
+            return None;
+        }
+        let status = self.with_current(|| unsafe {
+            let status = match PROCS.glGetGraphicsResetStatusKHR() {
+                0 => return Ok(None),
+                GL_GUILTY_CONTEXT_RESET_ARB => ResetStatus::Guilty,
+                GL_INNOCENT_CONTEXT_RESET_ARB => ResetStatus::Innocent,
+                GL_UNKNOWN_CONTEXT_RESET_ARB => ResetStatus::Unknown,
+                n => ResetStatus::Other(n),
+            };
+            Ok(Some(status))
+        });
+        status.unwrap_or_default()
+    }
+
+    #[inline]
+    pub fn with_current<T, F: FnOnce() -> Result<T, RenderError>>(
+        &self,
+        f: F,
+    ) -> Result<T, RenderError> {
+        unsafe {
+            if CURRENT == self.ctx {
+                return f();
+            }
+            self.with_current_slow(f)
+        }
+    }
+
+    #[cold]
+    unsafe fn with_current_slow<T, F: FnOnce() -> Result<T, RenderError>>(
+        &self,
+        f: F,
+    ) -> Result<T, RenderError> {
+        if eglMakeCurrent(
+            self.dpy.dpy,
+            EGLSurface::none(),
+            EGLSurface::none(),
+            self.ctx,
+        ) == EGL_FALSE
+        {
+            return Err(RenderError::MakeCurrent);
+        }
+        let prev = CURRENT;
+        CURRENT = self.ctx;
+        let res = f();
+        if eglMakeCurrent(self.dpy.dpy, EGLSurface::none(), EGLSurface::none(), prev) == EGL_FALSE {
+            panic!("Could not restore EGLContext");
+        }
+        CURRENT = prev;
+        res
+    }
+}

src/gfx_apis/gl/egl/display.rs

@@ -0,0 +1,325 @@
+use {
+    crate::{
+        format::{formats, Format},
+        gfx_apis::gl::{
+            egl::{
+                context::EglContext,
+                image::EglImage,
+                sys::{
+                    eglCreateContext, eglTerminate, EGLClientBuffer, EGLConfig, EGLContext,
+                    EGLDisplay, EGLint, EGL_CONTEXT_CLIENT_VERSION, EGL_DMA_BUF_PLANE0_FD_EXT,
+                    EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT,
+                    EGL_DMA_BUF_PLANE0_OFFSET_EXT, EGL_DMA_BUF_PLANE0_PITCH_EXT,
+                    EGL_DMA_BUF_PLANE1_FD_EXT, EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT,
+                    EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE1_OFFSET_EXT,
+                    EGL_DMA_BUF_PLANE1_PITCH_EXT, EGL_DMA_BUF_PLANE2_FD_EXT,
+                    EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT,
+                    EGL_DMA_BUF_PLANE2_OFFSET_EXT, EGL_DMA_BUF_PLANE2_PITCH_EXT,
+                    EGL_DMA_BUF_PLANE3_FD_EXT, EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT,
+                    EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE3_OFFSET_EXT,
+                    EGL_DMA_BUF_PLANE3_PITCH_EXT, EGL_HEIGHT, EGL_IMAGE_PRESERVED_KHR,
+                    EGL_LINUX_DMA_BUF_EXT, EGL_LINUX_DRM_FOURCC_EXT, EGL_NONE, EGL_TRUE, EGL_WIDTH,
+                },
+                PROCS,
+            },
+            ext::{get_display_ext, get_gl_ext, DisplayExt, GlExt},
+            sys::{
+                eglInitialize, EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT,
+                EGL_LOSE_CONTEXT_ON_RESET_EXT, EGL_PLATFORM_GBM_KHR,
+            },
+            RenderError,
+        },
+        video::{dmabuf::DmaBuf, drm::Drm, gbm::GbmDevice, INVALID_MODIFIER},
+    },
+    ahash::AHashMap,
+    std::{ptr, rc::Rc},
+};
+
+#[derive(Debug)]
+pub struct EglFormat {
+    pub format: &'static Format,
+    pub implicit_external_only: bool,
+    pub modifiers: AHashMap<u64, EglModifier>,
+}
+
+#[derive(Debug)]
+pub struct EglModifier {
+    pub modifier: u64,
+    pub external_only: bool,
+}
+
+#[derive(Debug)]
+pub struct EglDisplay {
+    pub exts: DisplayExt,
+    pub formats: Rc<AHashMap<u32, EglFormat>>,
+    pub gbm: Rc<GbmDevice>,
+    pub dpy: EGLDisplay,
+}
+
+impl EglDisplay {
+    pub fn create(drm: &Drm) -> Result<Rc<Self>, RenderError> {
+        unsafe {
+            let gbm = match GbmDevice::new(drm) {
+                Ok(gbm) => gbm,
+                Err(e) => return Err(RenderError::Gbm(e)),
+            };
+            let dpy = PROCS.eglGetPlatformDisplayEXT(
+                EGL_PLATFORM_GBM_KHR as _,
+                gbm.raw() as _,
+                ptr::null(),
+            );
+            if dpy.is_none() {
+                return Err(RenderError::GetDisplay);
+            }
+            let mut dpy = EglDisplay {
+                exts: DisplayExt::empty(),
+                formats: Rc::new(AHashMap::new()),
+                gbm: Rc::new(gbm),
+                dpy,
+            };
+            let mut major = 0;
+            let mut minor = 0;
+            if eglInitialize(dpy.dpy, &mut major, &mut minor) != EGL_TRUE {
+                return Err(RenderError::Initialize);
+            }
+            dpy.exts = get_display_ext(dpy.dpy);
+            if !dpy.exts.intersects(DisplayExt::KHR_IMAGE_BASE) {
+                return Err(RenderError::ImageBase);
+            }
+            if !dpy
+                .exts
+                .intersects(DisplayExt::EXT_IMAGE_DMA_BUF_IMPORT_MODIFIERS)
+            {
+                return Err(RenderError::DmaBufImport);
+            }
+            if !dpy
+                .exts
+                .intersects(DisplayExt::KHR_NO_CONFIG_CONTEXT | DisplayExt::MESA_CONFIGLESS_CONTEXT)
+            {
+                return Err(RenderError::ConfiglessContext);
+            }
+            if !dpy.exts.intersects(DisplayExt::KHR_SURFACELESS_CONTEXT) {
+                return Err(RenderError::SurfacelessContext);
+            }
+            dpy.formats = Rc::new(query_formats(dpy.dpy)?);
+
+            Ok(Rc::new(dpy))
+        }
+    }
+
+    pub fn create_context(self: &Rc<Self>) -> Result<Rc<EglContext>, RenderError> {
+        let mut attrib = vec![EGL_CONTEXT_CLIENT_VERSION, 2];
+        if self
+            .exts
+            .contains(DisplayExt::EXT_CREATE_CONTEXT_ROBUSTNESS)
+        {
+            attrib.push(EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT);
+            attrib.push(EGL_LOSE_CONTEXT_ON_RESET_EXT);
+        } else {
+            log::warn!("EGL display does not support gpu reset notifications");
+        }
+        attrib.push(EGL_NONE);
+        unsafe {
+            let ctx = eglCreateContext(
+                self.dpy,
+                EGLConfig::none(),
+                EGLContext::none(),
+                attrib.as_ptr(),
+            );
+            if ctx.is_none() {
+                return Err(RenderError::CreateContext);
+            }
+            let mut ctx = EglContext {
+                dpy: self.clone(),
+                ext: GlExt::empty(),
+                ctx,
+            };
+            ctx.ext = ctx.with_current(|| Ok(get_gl_ext()))?;
+            if !ctx.ext.contains(GlExt::GL_OES_EGL_IMAGE) {
+                return Err(RenderError::OesEglImage);
+            }
+            Ok(Rc::new(ctx))
+        }
+    }
+
+    pub fn import_dmabuf(self: &Rc<Self>, buf: &DmaBuf) -> Result<Rc<EglImage>, RenderError> {
+        let format = match self.formats.get(&buf.format.drm) {
+            Some(fmt) => match fmt.modifiers.get(&buf.modifier) {
+                Some(fmt) => fmt,
+                _ => return Err(RenderError::UnsupportedModifier),
+            },
+            _ => return Err(RenderError::UnsupportedFormat),
+        };
+        struct PlaneKey {
+            fd: EGLint,
+            offset: EGLint,
+            pitch: EGLint,
+            mod_lo: EGLint,
+            mod_hi: EGLint,
+        }
+        const PLANE_KEYS: [PlaneKey; 4] = [
+            PlaneKey {
+                fd: EGL_DMA_BUF_PLANE0_FD_EXT,
+                offset: EGL_DMA_BUF_PLANE0_OFFSET_EXT,
+                pitch: EGL_DMA_BUF_PLANE0_PITCH_EXT,
+                mod_lo: EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT,
+                mod_hi: EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT,
+            },
+            PlaneKey {
+                fd: EGL_DMA_BUF_PLANE1_FD_EXT,
+                offset: EGL_DMA_BUF_PLANE1_OFFSET_EXT,
+                pitch: EGL_DMA_BUF_PLANE1_PITCH_EXT,
+                mod_lo: EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT,
+                mod_hi: EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT,
+            },
+            PlaneKey {
+                fd: EGL_DMA_BUF_PLANE2_FD_EXT,
+                offset: EGL_DMA_BUF_PLANE2_OFFSET_EXT,
+                pitch: EGL_DMA_BUF_PLANE2_PITCH_EXT,
+                mod_lo: EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT,
+                mod_hi: EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT,
+            },
+            PlaneKey {
+                fd: EGL_DMA_BUF_PLANE3_FD_EXT,
+                offset: EGL_DMA_BUF_PLANE3_OFFSET_EXT,
+                pitch: EGL_DMA_BUF_PLANE3_PITCH_EXT,
+                mod_lo: EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT,
+                mod_hi: EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT,
+            },
+        ];
+
+        let mut attribs = Vec::with_capacity(19);
+        attribs.extend_from_slice(&[EGL_WIDTH, buf.width]);
+        attribs.extend_from_slice(&[EGL_HEIGHT, buf.height]);
+        attribs.extend_from_slice(&[EGL_LINUX_DRM_FOURCC_EXT, buf.format.drm as _]);
+        attribs.extend_from_slice(&[EGL_IMAGE_PRESERVED_KHR, EGL_TRUE as _]);
+        for (key, plane) in PLANE_KEYS.iter().zip(buf.planes.iter()) {
+            attribs.extend_from_slice(&[key.fd, plane.fd.raw()]);
+            attribs.extend_from_slice(&[key.pitch, plane.stride as _]);
+            attribs.extend_from_slice(&[key.offset, plane.offset as _]);
+            if buf.modifier != INVALID_MODIFIER {
+                attribs.extend_from_slice(&[key.mod_lo, buf.modifier as i32]);
+                attribs.extend_from_slice(&[key.mod_hi, (buf.modifier >> 32) as i32]);
+            }
+        }
+        attribs.push(EGL_NONE);
+        let img = unsafe {
+            PROCS.eglCreateImageKHR(
+                self.dpy,
+                EGLContext::none(),
+                EGL_LINUX_DMA_BUF_EXT as _,
+                EGLClientBuffer::none(),
+                attribs.as_ptr(),
+            )
+        };
+        if img.is_none() {
+            return Err(RenderError::CreateImage);
+        }
+        Ok(Rc::new(EglImage {
+            dpy: self.clone(),
+            img,
+            width: buf.width,
+            height: buf.height,
+            external_only: format.external_only,
+        }))
+    }
+}
+
+impl Drop for EglDisplay {
+    fn drop(&mut self) {
+        unsafe {
+            if eglTerminate(self.dpy) != EGL_TRUE {
+                log::warn!("`eglTerminate` failed");
+            }
+        }
+    }
+}
+
+unsafe fn query_formats(dpy: EGLDisplay) -> Result<AHashMap<u32, EglFormat>, RenderError> {
+    let mut vec = vec![];
+    let mut num = 0;
+    let res = PROCS.eglQueryDmaBufFormatsEXT(dpy, num, ptr::null_mut(), &mut num);
+    if res != EGL_TRUE {
+        return Err(RenderError::QueryDmaBufFormats);
+    }
+    vec.reserve_exact(num as usize);
+    let res = PROCS.eglQueryDmaBufFormatsEXT(dpy, num, vec.as_mut_ptr(), &mut num);
+    if res != EGL_TRUE {
+        return Err(RenderError::QueryDmaBufFormats);
+    }
+    vec.set_len(num as usize);
+    let mut res = AHashMap::new();
+    let formats = formats();
+    for fmt in vec {
+        if let Some(format) = formats.get(&(fmt as u32)) {
+            let (modifiers, external_only) = query_modifiers(dpy, fmt, format)?;
+            res.insert(
+                format.drm,
+                EglFormat {
+                    format,
+                    implicit_external_only: external_only,
+                    modifiers,
+                },
+            );
+        }
+    }
+    Ok(res)
+}
+
+unsafe fn query_modifiers(
+    dpy: EGLDisplay,
+    gl_format: EGLint,
+    format: &'static Format,
+) -> Result<(AHashMap<u64, EglModifier>, bool), RenderError> {
+    let mut mods = vec![];
+    let mut ext_only = vec![];
+    let mut num = 0;
+    let res = PROCS.eglQueryDmaBufModifiersEXT(
+        dpy,
+        gl_format,
+        num,
+        ptr::null_mut(),
+        ptr::null_mut(),
+        &mut num,
+    );
+    if res != EGL_TRUE {
+        return Err(RenderError::QueryDmaBufModifiers);
+    }
+    mods.reserve_exact(num as usize);
+    ext_only.reserve_exact(num as usize);
+    let res = PROCS.eglQueryDmaBufModifiersEXT(
+        dpy,
+        gl_format,
+        num,
+        mods.as_mut_ptr(),
+        ext_only.as_mut_ptr(),
+        &mut num,
+    );
+    if res != EGL_TRUE {
+        return Err(RenderError::QueryDmaBufModifiers);
+    }
+    mods.set_len(num as usize);
+    ext_only.set_len(num as usize);
+    let mut res = AHashMap::new();
+    for (modifier, ext_only) in mods.iter().copied().zip(ext_only.iter().copied()) {
+        res.insert(
+            modifier as _,
+            EglModifier {
+                modifier: modifier as _,
+                external_only: ext_only == EGL_TRUE,
+            },
+        );
+    }
+    let mut external_only = format.external_only_guess;
+    if res.len() > 0 {
+        external_only = res.values().any(|f| f.external_only);
+    }
+    res.insert(
+        INVALID_MODIFIER,
+        EglModifier {
+            modifier: INVALID_MODIFIER,
+            external_only,
+        },
+    );
+    Ok((res, external_only))
+}

src/gfx_apis/gl/egl/image.rs

@@ -0,0 +1,26 @@
+use {
+    crate::gfx_apis::gl::egl::{
+        display::EglDisplay,
+        sys::{EGLImageKHR, EGL_FALSE},
+        PROCS,
+    },
+    std::rc::Rc,
+};
+
+pub struct EglImage {
+    pub dpy: Rc<EglDisplay>,
+    pub img: EGLImageKHR,
+    pub width: i32,
+    pub height: i32,
+    pub external_only: bool,
+}
+
+impl Drop for EglImage {
+    fn drop(&mut self) {
+        unsafe {
+            if PROCS.eglDestroyImageKHR(self.dpy.dpy, self.img) == EGL_FALSE {
+                log::warn!("`eglDestroyImageKHR` failed");
+            }
+        }
+    }
+}

src/gfx_apis/gl/egl/sys.rs

@@ -0,0 +1,107 @@
+use {crate::gfx_apis::gl::sys::GLenum, uapi::c};
+
+pub type EGLint = i32;
+pub type EGLenum = c::c_uint;
+pub type EGLBoolean = c::c_uint;
+#[allow(dead_code)]
+pub type EGLuint64KHR = u64;
+pub type EGLAttrib = isize;
+
+egl_transparent!(EGLDisplay);
+egl_transparent!(EGLSurface);
+egl_transparent!(EGLConfig);
+egl_transparent!(EGLImageKHR);
+egl_transparent!(EGLContext);
+egl_transparent!(EGLClientBuffer);
+egl_transparent!(EGLLabelKHR);
+
+pub type EGLDEBUGPROCKHR = unsafe extern "C" fn(
+    error: EGLenum,
+    command: *const c::c_char,
+    message_type: EGLint,
+    thread_label: EGLLabelKHR,
+    object_label: EGLLabelKHR,
+    message: *const c::c_char,
+);
+
+pub const EGL_EXTENSIONS: EGLint = 0x3055;
+pub const EGL_DEBUG_MSG_CRITICAL_KHR: EGLint = 0x33B9;
+pub const EGL_DEBUG_MSG_ERROR_KHR: EGLint = 0x33BA;
+pub const EGL_DEBUG_MSG_WARN_KHR: EGLint = 0x33BB;
+pub const EGL_DEBUG_MSG_INFO_KHR: EGLint = 0x33BC;
+pub const EGL_TRUE: EGLBoolean = 1;
+pub const EGL_FALSE: EGLBoolean = 0;
+pub const EGL_NONE: EGLint = 0x3038;
+pub const EGL_SUCCESS: EGLint = 0x3000;
+pub const EGL_NOT_INITIALIZED: EGLint = 0x3001;
+pub const EGL_BAD_ACCESS: EGLint = 0x3002;
+pub const EGL_BAD_ALLOC: EGLint = 0x3003;
+pub const EGL_BAD_ATTRIBUTE: EGLint = 0x3004;
+pub const EGL_BAD_CONFIG: EGLint = 0x3005;
+pub const EGL_BAD_CONTEXT: EGLint = 0x3006;
+pub const EGL_BAD_CURRENT_SURFACE: EGLint = 0x3007;
+pub const EGL_BAD_DISPLAY: EGLint = 0x3008;
+pub const EGL_BAD_MATCH: EGLint = 0x3009;
+pub const EGL_BAD_NATIVE_PIXMAP: EGLint = 0x300A;
+pub const EGL_BAD_NATIVE_WINDOW: EGLint = 0x300B;
+pub const EGL_BAD_PARAMETER: EGLint = 0x300C;
+pub const EGL_BAD_SURFACE: EGLint = 0x300D;
+pub const EGL_CONTEXT_LOST: EGLint = 0x300E;
+pub const EGL_BAD_DEVICE_EXT: EGLint = 0x322B;
+pub const EGL_OPENGL_ES_API: EGLenum = 0x30A0;
+pub const EGL_PLATFORM_GBM_KHR: EGLint = 0x31D7;
+pub const EGL_CONTEXT_CLIENT_VERSION: EGLint = 0x3098;
+pub const EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT: EGLint = 0x3138;
+pub const EGL_LOSE_CONTEXT_ON_RESET_EXT: EGLint = 0x31BF;
+
+pub const GL_GUILTY_CONTEXT_RESET_ARB: GLenum = 0x8253;
+pub const GL_INNOCENT_CONTEXT_RESET_ARB: GLenum = 0x8254;
+pub const GL_UNKNOWN_CONTEXT_RESET_ARB: GLenum = 0x8255;
+
+pub const EGL_WIDTH: EGLint = 0x3057;
+pub const EGL_HEIGHT: EGLint = 0x3056;
+pub const EGL_LINUX_DRM_FOURCC_EXT: EGLint = 0x3271;
+pub const EGL_DMA_BUF_PLANE0_FD_EXT: EGLint = 0x3272;
+pub const EGL_DMA_BUF_PLANE0_OFFSET_EXT: EGLint = 0x3273;
+pub const EGL_DMA_BUF_PLANE0_PITCH_EXT: EGLint = 0x3274;
+pub const EGL_DMA_BUF_PLANE1_FD_EXT: EGLint = 0x3275;
+pub const EGL_DMA_BUF_PLANE1_OFFSET_EXT: EGLint = 0x3276;
+pub const EGL_DMA_BUF_PLANE1_PITCH_EXT: EGLint = 0x3277;
+pub const EGL_DMA_BUF_PLANE2_FD_EXT: EGLint = 0x3278;
+pub const EGL_DMA_BUF_PLANE2_OFFSET_EXT: EGLint = 0x3279;
+pub const EGL_DMA_BUF_PLANE2_PITCH_EXT: EGLint = 0x327A;
+pub const EGL_DMA_BUF_PLANE3_FD_EXT: EGLint = 0x3440;
+pub const EGL_DMA_BUF_PLANE3_OFFSET_EXT: EGLint = 0x3441;
+pub const EGL_DMA_BUF_PLANE3_PITCH_EXT: EGLint = 0x3442;
+pub const EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT: EGLint = 0x3443;
+pub const EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT: EGLint = 0x3444;
+pub const EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT: EGLint = 0x3445;
+pub const EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT: EGLint = 0x3446;
+pub const EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT: EGLint = 0x3447;
+pub const EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT: EGLint = 0x3448;
+pub const EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT: EGLint = 0x3449;
+pub const EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT: EGLint = 0x344A;
+pub const EGL_IMAGE_PRESERVED_KHR: EGLint = 0x30D2;
+pub const EGL_LINUX_DMA_BUF_EXT: EGLint = 0x3270;
+
+#[link(name = "EGL")]
+extern "C" {
+    pub fn eglQueryString(dpy: EGLDisplay, name: EGLint) -> *const c::c_char;
+    pub fn eglGetProcAddress(procname: *const c::c_char) -> *mut u8;
+    pub fn eglBindAPI(api: EGLenum) -> EGLBoolean;
+    pub fn eglTerminate(dpy: EGLDisplay) -> EGLBoolean;
+    pub fn eglInitialize(dpy: EGLDisplay, major: *mut EGLint, minor: *mut EGLint) -> EGLBoolean;
+    pub fn eglCreateContext(
+        dpy: EGLDisplay,
+        config: EGLConfig,
+        share_context: EGLContext,
+        attrib_list: *const EGLint,
+    ) -> EGLContext;
+    pub fn eglDestroyContext(dpy: EGLDisplay, ctx: EGLContext) -> EGLBoolean;
+    pub fn eglMakeCurrent(
+        dpy: EGLDisplay,
+        draw: EGLSurface,
+        read: EGLSurface,
+        ctx: EGLContext,
+    ) -> EGLBoolean;
+}