wayland: add support for NV12 format

src/render/renderer/context.rs

@@ -6,6 +6,7 @@ use {
                 context::EglContext,
                 display::{EglDisplay, EglFormat},
             },
+            ext::GlExt,
             gl::{
                 program::GlProgram, render_buffer::GlRenderBuffer, sys::GLint, texture::GlTexture,
             },
@@ -46,14 +47,19 @@ impl TexProg {
     }
 }
 
+pub(super) struct TexProgs {
+    pub alpha: TexProg,
+    pub solid: TexProg,
+}
+
 pub struct RenderContext {
     pub(super) ctx: Rc<EglContext>,
     pub gbm: Rc<GbmDevice>,
 
     pub(super) render_node: Rc<CString>,
 
-    pub(super) tex_prog: TexProg,
-    pub(super) tex_alpha_prog: TexProg,
+    pub(super) tex_internal: TexProgs,
+    pub(super) tex_external: Option<TexProgs>,
 
     pub(super) fill_prog: GlProgram,
     pub(super) fill_prog_pos: GLint,
@@ -79,6 +85,10 @@ impl RenderContext {
         self.ctx.reset_status()
     }
 
+    pub fn supports_external_texture(&self) -> bool {
+        self.ctx.ext.contains(GlExt::GL_OES_EGL_IMAGE_EXTERNAL)
+    }
+
     pub fn from_drm_device(drm: &Drm) -> Result<Self, RenderError> {
         let nodes = drm.get_nodes()?;
         let node = match nodes
@@ -97,16 +107,32 @@ impl RenderContext {
     }
 
     unsafe fn new(ctx: &Rc<EglContext>, node: &Rc<CString>) -> Result<Self, RenderError> {
-        let tex_prog = GlProgram::from_shaders(
-            ctx,
-            include_str!("../shaders/tex.vert.glsl"),
-            include_str!("../shaders/tex.frag.glsl"),
-        )?;
+        let tex_vert = include_str!("../shaders/tex.vert.glsl");
+        let tex_prog =
+            GlProgram::from_shaders(ctx, tex_vert, include_str!("../shaders/tex.frag.glsl"))?;
         let tex_alpha_prog = GlProgram::from_shaders(
             ctx,
-            include_str!("../shaders/tex.vert.glsl"),
+            tex_vert,
             include_str!("../shaders/tex-alpha.frag.glsl"),
         )?;
+        let tex_external = if ctx.ext.contains(GlExt::GL_OES_EGL_IMAGE_EXTERNAL) {
+            let solid = GlProgram::from_shaders(
+                ctx,
+                tex_vert,
+                include_str!("../shaders/tex-external.frag.glsl"),
+            )?;
+            let alpha = GlProgram::from_shaders(
+                ctx,
+                tex_vert,
+                include_str!("../shaders/tex-external-alpha.frag.glsl"),
+            )?;
+            Some(TexProgs {
+                alpha: TexProg::from(alpha),
+                solid: TexProg::from(solid),
+            })
+        } else {
+            None
+        };
         let fill_prog = GlProgram::from_shaders(
             ctx,
             include_str!("../shaders/fill.vert.glsl"),
@@ -118,8 +144,11 @@ impl RenderContext {
 
             render_node: node.clone(),
 
-            tex_prog: TexProg::from(tex_prog),
-            tex_alpha_prog: TexProg::from(tex_alpha_prog),
+            tex_internal: TexProgs {
+                solid: TexProg::from(tex_prog),
+                alpha: TexProg::from(tex_alpha_prog),
+            },
+            tex_external,
 
             fill_prog_pos: fill_prog.get_attrib_location(ustr!("pos")),
             fill_prog_color: fill_prog.get_uniform_location(ustr!("color")),

src/render/renderer/renderer.rs

@@ -17,9 +17,9 @@ use {
                     glActiveTexture, glBindTexture, glDisableVertexAttribArray, glDrawArrays,
                     glEnableVertexAttribArray, glTexParameteri, glUniform1i, glUniform4f,
                     glUseProgram, glVertexAttribPointer, GL_FALSE, GL_FLOAT, GL_LINEAR,
-                    GL_TEXTURE0, GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_TRIANGLES,
-                    GL_TRIANGLE_STRIP,
+                    GL_TEXTURE0, GL_TEXTURE_MIN_FILTER, GL_TRIANGLES, GL_TRIANGLE_STRIP,
                 },
+                texture::image_target,
             },
             renderer::context::RenderContext,
             sys::{glDisable, glEnable, GL_BLEND},
@@ -359,17 +359,29 @@ impl Renderer<'_> {
         unsafe {
             glActiveTexture(GL_TEXTURE0);
 
-            glBindTexture(GL_TEXTURE_2D, texture.gl.tex);
-            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            let target = image_target(texture.gl.external_only);
 
+            glBindTexture(target, texture.gl.tex);
+            glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+            let progs = match texture.gl.external_only {
+                true => match &self.ctx.tex_external {
+                    Some(p) => p,
+                    _ => {
+                        log::error!("Trying to render an external-only texture but context does not support the required extension");
+                        return;
+                    }
+                },
+                false => &self.ctx.tex_internal,
+            };
             let prog = match format.has_alpha {
                 true => {
                     glEnable(GL_BLEND);
-                    &self.ctx.tex_alpha_prog
+                    &progs.alpha
                 }
                 false => {
                     glDisable(GL_BLEND);
-                    &self.ctx.tex_prog
+                    &progs.solid
                 }
             };
 
@@ -423,7 +435,7 @@ impl Renderer<'_> {
             glDisableVertexAttribArray(prog.texcoord as _);
             glDisableVertexAttribArray(prog.pos as _);
 
-            glBindTexture(GL_TEXTURE_2D, 0);
+            glBindTexture(target, 0);
         }
     }