libservo: Expose an OffscreenRenderingContext and use it for servoshell (#35465)

Create a new `RenderingContext` which is used to render to a
`SurfmanRenderingContext`-related offscreen buffer. This allows having a
temporary place to render Servo and then blitting the results to a
subsection of the parent `RenderingContext`.

The goal with this change is to remove the details of how servoshell
renders from the `Compositor` and prepare for the compositor-per-WebView
world.


Co-authred-by: Ngo Iok Ui (Wu Yu Wei) <yuweiwu@pm.me>

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
Co-authored-by: Mukilan Thiyagarajan <mukilan@igalia.com>

components/shared/webrender/Cargo.toml

@@ -10,6 +10,7 @@ rust-version.workspace = true
 [lib]
 name = "webrender_traits"
 path = "lib.rs"
+test = true
 
 [features]
 no-wgl = ["surfman/sm-angle-default"]
@@ -18,10 +19,12 @@ no-wgl = ["surfman/sm-angle-default"]
 base = { workspace = true }
 embedder_traits = { workspace = true }
 euclid = { workspace = true }
+image = { workspace = true }
 ipc-channel = { workspace = true }
 log = { workspace = true }
 libc = { workspace = true }
 gleam = { workspace = true }
+glow = { workspace = true }
 webrender_api = { workspace = true }
 serde = { workspace = true }
 servo_geometry = { path = "../../geometry" }

components/shared/webrender/rendering_context.rs

@@ -4,13 +4,17 @@
 
 #![deny(unsafe_code)]
 
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::ffi::c_void;
+use std::num::NonZeroU32;
 use std::rc::Rc;
 
-use euclid::default::Size2D;
-use gleam::gl;
-use log::{debug, warn};
+use euclid::default::{Rect, Size2D};
+use euclid::Point2D;
+use gleam::gl::{self, Gl};
+use glow::NativeFramebuffer;
+use image::RgbaImage;
+use log::{debug, trace, warn};
 use servo_media::player::context::{GlContext, NativeDisplay};
 use surfman::chains::{PreserveBuffer, SwapChain};
 #[cfg(all(target_os = "linux", not(target_env = "ohos")))]
@@ -36,16 +40,26 @@ pub enum GLVersion {
 /// management, and destruction of the rendering context and its associated
 /// resources.
 pub trait RenderingContext {
+    /// Prepare this [`RenderingContext`] to be rendered upon by Servo. For instance,
+    /// by binding a framebuffer to the current OpenGL context.
+    fn prepare_for_rendering(&self) {}
+    /// Read the contents of this [`Renderingcontext`] into an in-memory image. If the
+    /// image cannot be read (for instance, if no rendering has taken place yet), then
+    /// `None` is returned.
+    ///
+    /// In a double-buffered [`RenderingContext`] this is expected to read from the back
+    /// buffer. That means that once Servo renders to the context, this should return those
+    /// results, even before [`RenderingContext::present`] is called.
+    fn read_to_image(&self, source_rectangle: Rect<u32>) -> Option<RgbaImage>;
     /// Resizes the rendering surface to the given size.
     fn resize(&self, size: Size2D<i32>);
-    /// Presents the rendered frame to the screen.
+    /// Presents the rendered frame to the screen. In a double-buffered context, this would
+    /// swap buffers.
     fn present(&self);
     /// Makes the context the current OpenGL context for this thread.
     /// After calling this function, it is valid to use OpenGL rendering
     /// commands.
     fn make_current(&self) -> Result<(), Error>;
-    /// Returns the OpenGL framebuffer object needed to render to the surface.
-    fn framebuffer_object(&self) -> u32;
     /// Returns the OpenGL or GLES API.
     fn gl_api(&self) -> Rc<dyn gleam::gl::Gl>;
     /// Describes the OpenGL version that is requested when a context is created.
@@ -86,6 +100,7 @@ pub trait RenderingContext {
 pub struct SurfmanRenderingContext(Rc<RenderingContextData>);
 
 struct RenderingContextData {
+    gl: Rc<dyn Gl>,
     device: RefCell<Device>,
     context: RefCell<Context>,
     // We either render to a swap buffer or to a native widget
@@ -164,6 +179,23 @@ impl RenderingContext for SurfmanRenderingContext {
             NativeDisplay::Unknown
         }
     }
+
+    fn prepare_for_rendering(&self) {
+        self.0.gl.bind_framebuffer(
+            gleam::gl::FRAMEBUFFER,
+            self.framebuffer()
+                .map_or(0, |framebuffer| framebuffer.0.into()),
+        );
+    }
+
+    fn read_to_image(&self, source_rectangle: Rect<u32>) -> Option<RgbaImage> {
+        let framebuffer_id = self
+            .framebuffer()
+            .map(|framebuffer| framebuffer.0.into())
+            .unwrap_or(0);
+        Framebuffer::read_framebuffer_to_image(self.gl_api(), framebuffer_id, source_rectangle)
+    }
+
     fn resize(&self, size: Size2D<i32>) {
         if let Err(err) = self.resize(size) {
             warn!("Failed to resize surface: {:?}", err);
@@ -177,23 +209,9 @@ impl RenderingContext for SurfmanRenderingContext {
     fn make_current(&self) -> Result<(), Error> {
         self.make_gl_context_current()
     }
-    fn framebuffer_object(&self) -> u32 {
-        self.context_surface_info()
-            .unwrap_or(None)
-            .and_then(|info| info.framebuffer_object)
-            .map(|fbo| fbo.0.get())
-            .unwrap_or(0)
-    }
     #[allow(unsafe_code)]
     fn gl_api(&self) -> Rc<dyn gleam::gl::Gl> {
-        let context = self.0.context.borrow();
-        let device = self.0.device.borrow();
-        match self.connection().gl_api() {
-            GLApi::GL => unsafe { gl::GlFns::load_with(|s| device.get_proc_address(&context, s)) },
-            GLApi::GLES => unsafe {
-                gl::GlesFns::load_with(|s| device.get_proc_address(&context, s))
-            },
-        }
+        self.0.gl.clone()
     }
     fn gl_version(&self) -> GLVersion {
         let device = self.0.device.borrow();
@@ -270,9 +288,23 @@ impl SurfmanRenderingContext {
         } else {
             None
         };
+
+        #[allow(unsafe_code)]
+        let gl = {
+            match connection.gl_api() {
+                GLApi::GL => unsafe {
+                    gl::GlFns::load_with(|s| device.get_proc_address(&context, s))
+                },
+                GLApi::GLES => unsafe {
+                    gl::GlesFns::load_with(|s| device.get_proc_address(&context, s))
+                },
+            }
+        };
+
         let device = RefCell::new(device);
         let context = RefCell::new(context);
         let data = RenderingContextData {
+            gl,
             device,
             context,
             swap_chain,
@@ -464,4 +496,367 @@ impl SurfmanRenderingContext {
         device.make_context_current(&context)?;
         Ok(())
     }
+
+    pub fn framebuffer(&self) -> Option<NativeFramebuffer> {
+        self.context_surface_info()
+            .unwrap_or(None)
+            .and_then(|info| info.framebuffer_object)
+    }
+
+    /// Create a new offscreen context that is compatible with this [`SurfmanRenderingContext`].
+    /// The contents of the resulting [`OffscreenRenderingContext`] are guaranteed to be blit
+    /// compatible with the this context.
+    pub fn offscreen_context(&self, size: Size2D<u32>) -> OffscreenRenderingContext {
+        OffscreenRenderingContext::new(SurfmanRenderingContext(self.0.clone()), size)
+    }
+}
+
+struct Framebuffer {
+    gl: Rc<dyn Gl>,
+    size: Size2D<u32>,
+    framebuffer_id: gl::GLuint,
+    renderbuffer_id: gl::GLuint,
+    texture_id: gl::GLuint,
+}
+
+impl Framebuffer {
+    fn bind(&self) {
+        trace!("Binding FBO {}", self.framebuffer_id);
+        self.gl
+            .bind_framebuffer(gl::FRAMEBUFFER, self.framebuffer_id)
+    }
+}
+
+impl Drop for Framebuffer {
+    fn drop(&mut self) {
+        self.gl.bind_framebuffer(gl::FRAMEBUFFER, 0);
+        self.gl.delete_textures(&[self.texture_id]);
+        self.gl.delete_renderbuffers(&[self.renderbuffer_id]);
+        self.gl.delete_framebuffers(&[self.framebuffer_id]);
+    }
+}
+
+impl Framebuffer {
+    fn new(gl: Rc<dyn Gl>, size: Size2D<u32>) -> Self {
+        let framebuffer_ids = gl.gen_framebuffers(1);
+        gl.bind_framebuffer(gl::FRAMEBUFFER, framebuffer_ids[0]);
+
+        let texture_ids = gl.gen_textures(1);
+        gl.bind_texture(gl::TEXTURE_2D, texture_ids[0]);
+        gl.tex_image_2d(
+            gl::TEXTURE_2D,
+            0,
+            gl::RGBA as gl::GLint,
+            size.width as gl::GLsizei,
+            size.height as gl::GLsizei,
+            0,
+            gl::RGBA,
+            gl::UNSIGNED_BYTE,
+            None,
+        );
+        gl.tex_parameter_i(
+            gl::TEXTURE_2D,
+            gl::TEXTURE_MAG_FILTER,
+            gl::NEAREST as gl::GLint,
+        );
+        gl.tex_parameter_i(
+            gl::TEXTURE_2D,
+            gl::TEXTURE_MIN_FILTER,
+            gl::NEAREST as gl::GLint,
+        );
+
+        gl.framebuffer_texture_2d(
+            gl::FRAMEBUFFER,
+            gl::COLOR_ATTACHMENT0,
+            gl::TEXTURE_2D,
+            texture_ids[0],
+            0,
+        );
+
+        gl.bind_texture(gl::TEXTURE_2D, 0);
+
+        let renderbuffer_ids = gl.gen_renderbuffers(1);
+        let depth_rb = renderbuffer_ids[0];
+        gl.bind_renderbuffer(gl::RENDERBUFFER, depth_rb);
+        gl.renderbuffer_storage(
+            gl::RENDERBUFFER,
+            gl::DEPTH_COMPONENT24,
+            size.width as gl::GLsizei,
+            size.height as gl::GLsizei,
+        );
+        gl.framebuffer_renderbuffer(
+            gl::FRAMEBUFFER,
+            gl::DEPTH_ATTACHMENT,
+            gl::RENDERBUFFER,
+            depth_rb,
+        );
+
+        Self {
+            gl,
+            size,
+            framebuffer_id: *framebuffer_ids
+                .first()
+                .expect("Guaranteed by GL operations"),
+            renderbuffer_id: *renderbuffer_ids
+                .first()
+                .expect("Guaranteed by GL operations"),
+            texture_id: *texture_ids.first().expect("Guaranteed by GL operations"),
+        }
+    }
+
+    fn read_to_image(&self, source_rectangle: Rect<u32>) -> Option<RgbaImage> {
+        Self::read_framebuffer_to_image(self.gl.clone(), self.framebuffer_id, source_rectangle)
+    }
+
+    fn read_framebuffer_to_image(
+        gl: Rc<dyn Gl>,
+        framebuffer_id: u32,
+        source_rectangle: Rect<u32>,
+    ) -> Option<RgbaImage> {
+        gl.bind_framebuffer(gl::FRAMEBUFFER, framebuffer_id);
+
+        // For some reason, OSMesa fails to render on the 3rd
+        // attempt in headless mode, under some conditions.
+        // I think this can only be some kind of synchronization
+        // bug in OSMesa, but explicitly un-binding any vertex
+        // array here seems to work around that bug.
+        // See https://github.com/servo/servo/issues/18606.
+        gl.bind_vertex_array(0);
+
+        let mut pixels = gl.read_pixels(
+            source_rectangle.origin.x as i32,
+            source_rectangle.origin.y as i32,
+            source_rectangle.width() as gl::GLsizei,
+            source_rectangle.height() as gl::GLsizei,
+            gl::RGBA,
+            gl::UNSIGNED_BYTE,
+        );
+        let gl_error = gl.get_error();
+        if gl_error != gl::NO_ERROR {
+            warn!("GL error code 0x{gl_error:x} set after read_pixels");
+        }
+
+        // flip image vertically (texture is upside down)
+        let source_rectangle = source_rectangle.to_usize();
+        let orig_pixels = pixels.clone();
+        let stride = source_rectangle.width() * 4;
+        for y in 0..source_rectangle.height() {
+            let dst_start = y * stride;
+            let src_start = (source_rectangle.height() - y - 1) * stride;
+            let src_slice = &orig_pixels[src_start..src_start + stride];
+            pixels[dst_start..dst_start + stride].clone_from_slice(&src_slice[..stride]);
+        }
+
+        RgbaImage::from_raw(
+            source_rectangle.width() as u32,
+            source_rectangle.height() as u32,
+            pixels,
+        )
+    }
+}
+
+pub struct OffscreenRenderingContext {
+    parent_context: SurfmanRenderingContext,
+    size: Cell<Size2D<u32>>,
+    back_framebuffer: RefCell<Framebuffer>,
+    front_framebuffer: RefCell<Option<Framebuffer>>,
+}
+
+type RenderToParentCallback = Box<dyn Fn(&glow::Context, Rect<i32>) + Send + Sync>;
+
+impl OffscreenRenderingContext {
+    fn new(parent_context: SurfmanRenderingContext, size: Size2D<u32>) -> Self {
+        let next_framebuffer = Framebuffer::new(parent_context.gl_api(), size);
+        Self {
+            parent_context,
+            size: Cell::new(size),
+            back_framebuffer: RefCell::new(next_framebuffer),
+            front_framebuffer: Default::default(),
+        }
+    }
+
+    pub fn parent_context(&self) -> &SurfmanRenderingContext {
+        &self.parent_context
+    }
+
+    pub fn front_framebuffer_id(&self) -> Option<gl::GLuint> {
+        self.front_framebuffer
+            .borrow()
+            .as_ref()
+            .map(|framebuffer| framebuffer.framebuffer_id)
+    }
+
+    pub fn render_to_parent_callback(&self) -> Option<RenderToParentCallback> {
+        // Don't accept a `None` context for the read framebuffer.
+        let front_framebuffer_id =
+            NonZeroU32::new(self.front_framebuffer_id()?).map(NativeFramebuffer)?;
+        let parent_context_framebuffer_id = self.parent_context.framebuffer();
+        let size = self.size.get();
+        Some(Box::new(move |gl, target_rect| {
+            Self::render_framebuffer_to_parent_context(
+                gl,
+                Rect::new(Point2D::origin(), size.to_i32()),
+                front_framebuffer_id,
+                target_rect,
+                parent_context_framebuffer_id,
+            );
+        }))
+    }
+
+    #[allow(unsafe_code)]
+    fn render_framebuffer_to_parent_context(
+        gl: &glow::Context,
+        source_rect: Rect<i32>,
+        source_framebuffer_id: NativeFramebuffer,
+        target_rect: Rect<i32>,
+        target_framebuffer_id: Option<NativeFramebuffer>,
+    ) {
+        use glow::HasContext as _;
+        unsafe {
+            gl.clear_color(0.0, 0.0, 0.0, 0.0);
+            gl.scissor(
+                target_rect.origin.x,
+                target_rect.origin.y,
+                target_rect.width(),
+                target_rect.height(),
+            );
+            gl.enable(gl::SCISSOR_TEST);
+            gl.clear(gl::COLOR_BUFFER_BIT);
+            gl.disable(gl::SCISSOR_TEST);
+
+            gl.bind_framebuffer(gl::READ_FRAMEBUFFER, Some(source_framebuffer_id));
+            gl.bind_framebuffer(gl::DRAW_FRAMEBUFFER, target_framebuffer_id);
+
+            gl.blit_framebuffer(
+                source_rect.origin.x,
+                source_rect.origin.y,
+                source_rect.origin.x + source_rect.width(),
+                source_rect.origin.y + source_rect.height(),
+                target_rect.origin.x,
+                target_rect.origin.y,
+                target_rect.origin.x + target_rect.width(),
+                target_rect.origin.y + target_rect.height(),
+                gl::COLOR_BUFFER_BIT,
+                gl::NEAREST,
+            );
+            gl.bind_framebuffer(gl::FRAMEBUFFER, target_framebuffer_id);
+        }
+    }
+}
+
+impl RenderingContext for OffscreenRenderingContext {
+    fn resize(&self, size: Size2D<i32>) {
+        // We do not resize any buffers right now. The current buffers might be too big or too
+        // small, but we only want to ensure (later) that next buffer that we draw to is the
+        // correct size.
+        self.size.set(size.to_u32());
+    }
+
+    fn prepare_for_rendering(&self) {
+        self.back_framebuffer.borrow().bind();
+    }
+
+    fn present(&self) {
+        trace!(
+            "Unbinding FBO {}",
+            self.back_framebuffer.borrow().framebuffer_id
+        );
+        self.gl_api().bind_framebuffer(gl::FRAMEBUFFER, 0);
+
+        let new_back_framebuffer = match self.front_framebuffer.borrow_mut().take() {
+            Some(framebuffer) if framebuffer.size == self.size.get() => framebuffer,
+            _ => Framebuffer::new(self.gl_api(), self.size.get()),
+        };
+
+        let new_front_framebuffer = std::mem::replace(
+            &mut *self.back_framebuffer.borrow_mut(),
+            new_back_framebuffer,
+        );
+        *self.front_framebuffer.borrow_mut() = Some(new_front_framebuffer);
+    }
+
+    fn make_current(&self) -> Result<(), surfman::Error> {
+        self.parent_context.make_gl_context_current()
+    }
+
+    fn gl_api(&self) -> Rc<dyn gleam::gl::Gl> {
+        self.parent_context.gl_api()
+    }
+
+    fn gl_version(&self) -> GLVersion {
+        self.parent_context.gl_version()
+    }
+
+    fn create_texture(&self, surface: Surface) -> Option<(SurfaceTexture, u32, Size2D<i32>)> {
+        self.parent_context.create_texture(surface)
+    }
+
+    fn destroy_texture(&self, surface_texture: SurfaceTexture) -> Option<Surface> {
+        self.parent_context.destroy_texture(surface_texture)
+    }
+
+    fn connection(&self) -> Option<Connection> {
+        Some(self.parent_context.connection())
+    }
+
+    fn read_to_image(&self, source_rectangle: Rect<u32>) -> Option<RgbaImage> {
+        self.back_framebuffer
+            .borrow()
+            .read_to_image(source_rectangle)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use euclid::{Point2D, Rect, Size2D};
+    use gleam::gl;
+    use image::Rgba;
+    use surfman::{Connection, ContextAttributeFlags, ContextAttributes, Error, GLApi, GLVersion};
+
+    use super::Framebuffer;
+
+    #[test]
+    #[allow(unsafe_code)]
+    fn test_read_pixels() -> Result<(), Error> {
+        let connection = Connection::new()?;
+        let adapter = connection.create_software_adapter()?;
+        let mut device = connection.create_device(&adapter)?;
+        let context_descriptor = device.create_context_descriptor(&ContextAttributes {
+            version: GLVersion::new(3, 0),
+            flags: ContextAttributeFlags::empty(),
+        })?;
+        let mut context = device.create_context(&context_descriptor, None)?;
+
+        let gl = match connection.gl_api() {
+            GLApi::GL => unsafe { gl::GlFns::load_with(|s| device.get_proc_address(&context, s)) },
+            GLApi::GLES => unsafe {
+                gl::GlesFns::load_with(|s| device.get_proc_address(&context, s))
+            },
+        };
+
+        device.make_context_current(&context)?;
+
+        {
+            const SIZE: u32 = 16;
+            let framebuffer = Framebuffer::new(gl, Size2D::new(SIZE, SIZE));
+            framebuffer.bind();
+            framebuffer
+                .gl
+                .clear_color(12.0 / 255.0, 34.0 / 255.0, 56.0 / 255.0, 78.0 / 255.0);
+            framebuffer.gl.clear(gl::COLOR_BUFFER_BIT);
+
+            let img = framebuffer
+                .read_to_image(Rect::new(Point2D::zero(), Size2D::new(SIZE, SIZE)))
+                .expect("Should have been able to read back image.");
+            assert_eq!(img.width(), SIZE);
+            assert_eq!(img.height(), SIZE);
+
+            let expected_pixel: Rgba<u8> = Rgba([12, 34, 56, 78]);
+            assert!(img.pixels().all(|&p| p == expected_pixel));
+        }
+
+        device.destroy_context(&mut context)?;
+
+        Ok(())
+    }
 }