Add an API for providing external images.

This allows applications to provide images without supplying
the image bytes up front. This can be useful if the application
doesn't have the bytes available immediately (e.g. video decoding)
or wants to manage the buffer allocation and reduce memory
copies.

Author: gw3583

sample/src/main.rs

@@ -8,8 +8,9 @@ use euclid::{Size2D, Point2D, Rect, Matrix4D};
 use gleam::gl;
 use std::path::PathBuf;
 use std::ffi::CStr;
-use webrender_traits::{AuxiliaryListsBuilder, ColorF, Epoch, GlyphInstance};
-use webrender_traits::{ImageFormat, PipelineId, RendererKind};
+use webrender::{ExternalImage, ExternalImageHandler};
+use webrender_traits::{AuxiliaryListsBuilder, ColorF, Epoch, GlyphInstance, ExternalImageId};
+use webrender_traits::{ImageData, ImageFormat, PipelineId, RendererKind, ImageRendering};
 use std::fs::File;
 use std::io::Read;
 use std::env;
@@ -53,6 +54,49 @@ impl webrender_traits::RenderNotifier for Notifier {
     }
 }
 
+struct ImageHandler {
+    data: Vec<u8>,
+    frame: u64,
+}
+
+impl ImageHandler {
+    fn new() -> ImageHandler {
+        ImageHandler {
+            frame: 0,
+            data: vec![ 0xff, 0x00, 0x00, 0xff,
+                        0x00, 0xff, 0x00, 0xff,
+                        0x00, 0x00, 0xff, 0xff,
+                        0x00, 0xff, 0xff, 0xff ],
+        }
+    }
+}
+
+impl ExternalImageHandler for ImageHandler {
+    fn lock_image(&mut self, _: ExternalImageId) -> ExternalImage {
+        self.frame += 1;
+
+        if self.frame == 10 {
+            self.data = vec![ 0x00, 0x00, 0x00, 0xff,
+                              0xff, 0xff, 0xff, 0xff,
+                              0xff, 0xff, 0xff, 0xff,
+                              0x00, 0x00, 0x00, 0xff ];
+        }
+
+        ExternalImage {
+            timestamp: self.frame,
+            u0: 0.0,
+            v0: 0.0,
+            u1: 2.0,
+            v1: 2.0,
+            data: self.data.as_ptr(),
+            len: self.data.len(),
+        }
+    }
+
+    fn unlock_image(&mut self, _: ExternalImageId) {
+    }
+}
+
 fn main() {
     let args: Vec<String> = env::args().collect();
     if args.len() != 2 {
@@ -106,6 +150,7 @@ fn main() {
 
     let notifier = Box::new(Notifier::new(window.create_window_proxy()));
     renderer.set_render_notifier(notifier);
+    renderer.set_external_image_handler(Box::new(ImageHandler::new()));
 
     let pipeline_id = PipelineId(0, 0);
     let epoch = Epoch(0);
@@ -135,7 +180,7 @@ fn main() {
     let clip_region = {
         let rect = Rect::new(Point2D::new(100.0, 100.0), Size2D::new(100.0, 100.0));
         let mask = webrender_traits::ImageMask {
-            image: api.add_image(2, 2, None, ImageFormat::A8, vec![0,80, 180, 255]),
+            image: api.add_image(2, 2, None, ImageFormat::A8, ImageData::Raw(vec![0,80, 180, 255])),
             rect: rect,
             repeat: false,
         };
@@ -154,6 +199,22 @@ fn main() {
 
     let _text_bounds = Rect::new(Point2D::new(100.0, 200.0), Size2D::new(700.0, 300.0));
 
+    let ext_id = ExternalImageId(0);
+    let image_key = api.add_image(2, 2, None, ImageFormat::RGBA8, ImageData::External(ext_id));
+
+    let ext_image_rect = Rect::new(Point2D::new(300.0, 100.0), Size2D::new(100.0, 100.0));
+    let ext_image_clip_region = webrender_traits::ClipRegion::new(&ext_image_rect,
+                                                                  vec![],
+                                                                  None,
+                                                                  &mut auxiliary_lists_builder);
+
+    builder.push_image(ext_image_rect,
+                       ext_image_clip_region,
+                       Size2D::new(100.0, 100.0),
+                       Size2D::zero(),
+                       ImageRendering::Auto,
+                       image_key);
+
     let _glyphs = vec![
         GlyphInstance {
             index: 48,

webrender/res/cs_text_run.vs.glsl

@@ -13,17 +13,18 @@ void main(void) {
     TextRun text = fetch_text_run(cpi.specific_prim_index);
     Glyph glyph = fetch_glyph(cpi.sub_index);
     PrimitiveGeometry pg = fetch_prim_geometry(cpi.global_prim_index);
+    ResourceRect res = fetch_resource_rect(cpi.user_data.x);
 
     // Glyphs size is already in device-pixels.
     // The render task origin is in device-pixels. Offset that by
     // the glyph offset, relative to its primitive bounding rect.
-    vec2 size = glyph.uv_rect.zw - glyph.uv_rect.xy;
+    vec2 size = res.uv_rect.zw - res.uv_rect.xy;
     vec2 origin = task.data0.xy + uDevicePixelRatio * (glyph.offset.xy - pg.local_rect.xy);
     vec4 local_rect = vec4(origin, size);
 
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = glyph.uv_rect.xy / texture_size;
-    vec2 st1 = glyph.uv_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vec2 pos = mix(local_rect.xy,
                    local_rect.xy + local_rect.zw,

webrender/res/prim_shared.glsl

@@ -55,6 +55,7 @@ uniform sampler2D sData16;
 uniform sampler2D sData32;
 uniform sampler2D sData64;
 uniform sampler2D sData128;
+uniform sampler2D sResourceRects;
 
 ivec2 get_fetch_uv(int index, int vecs_per_item) {
     int items_per_row = WR_MAX_VERTEX_TEXTURE_WIDTH / vecs_per_item;
@@ -186,16 +187,14 @@ GradientStop fetch_gradient_stop(int index) {
 
 struct Glyph {
     vec4 offset;
-    vec4 uv_rect;
 };
 
 Glyph fetch_glyph(int index) {
     Glyph glyph;
 
-    ivec2 uv = get_fetch_uv_2(index);
+    ivec2 uv = get_fetch_uv_1(index);
 
-    glyph.offset = texelFetchOffset(sData32, uv, 0, ivec2(0, 0));
-    glyph.uv_rect = texelFetchOffset(sData32, uv, 0, ivec2(1, 0));
+    glyph.offset = texelFetchOffset(sData16, uv, 0, ivec2(0, 0));
 
     return glyph;
 }
@@ -302,19 +301,22 @@ struct CachePrimitiveInstance {
     int specific_prim_index;
     int render_task_index;
     int sub_index;
+    ivec4 user_data;
 };
 
 CachePrimitiveInstance fetch_cache_instance(int index) {
     CachePrimitiveInstance cpi;
 
-    int offset = index * 1;
+    int offset = index * 2;
 
     ivec4 data0 = int_data[offset + 0];
+    ivec4 data1 = int_data[offset + 1];
 
     cpi.global_prim_index = data0.x;
     cpi.specific_prim_index = data0.y;
     cpi.render_task_index = data0.z;
     cpi.sub_index = data0.w;
+    cpi.user_data = data1;
 
     return cpi;
 }
@@ -584,6 +586,20 @@ TransformVertexInfo write_transform_vertex(vec4 instance_rect,
 
 #endif //WR_FEATURE_TRANSFORM
 
+struct ResourceRect {
+    vec4 uv_rect;
+};
+
+ResourceRect fetch_resource_rect(int index) {
+    ResourceRect rect;
+
+    ivec2 uv = get_fetch_uv_1(index);
+
+    rect.uv_rect = texelFetchOffset(sResourceRects, uv, 0, ivec2(0, 0));
+
+    return rect;
+}
+
 struct Rectangle {
     vec4 color;
 };
@@ -613,18 +629,16 @@ TextRun fetch_text_run(int index) {
 }
 
 struct Image {
-    vec4 st_rect;                        // Location of the image texture in the texture atlas.
     vec4 stretch_size_and_tile_spacing;  // Size of the actual image and amount of space between
                                          //     tiled instances of this image.
 };
 
 Image fetch_image(int index) {
     Image image;
 
-    ivec2 uv = get_fetch_uv_2(index);
+    ivec2 uv = get_fetch_uv_1(index);
 
-    image.st_rect = texelFetchOffset(sData32, uv, 0, ivec2(0, 0));
-    image.stretch_size_and_tile_spacing = texelFetchOffset(sData32, uv, 0, ivec2(1, 0));
+    image.stretch_size_and_tile_spacing = texelFetchOffset(sData16, uv, 0, ivec2(0, 0));
 
     return image;
 }

webrender/res/ps_image.vs.glsl

@@ -6,6 +6,7 @@
 void main(void) {
     Primitive prim = load_primitive(gl_InstanceID);
     Image image = fetch_image(prim.prim_index);
+    ResourceRect res = fetch_resource_rect(prim.user_data.x);
 
 #ifdef WR_FEATURE_TRANSFORM
     TransformVertexInfo vi = write_transform_vertex(prim.local_rect,
@@ -24,8 +25,8 @@ void main(void) {
 
     // vUv will contain how many times this image has wrapped around the image size.
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = image.st_rect.xy / texture_size;
-    vec2 st1 = image.st_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vTextureSize = st1 - st0;
     vTextureOffset = st0;

webrender/res/ps_image_clip.vs.glsl

@@ -6,6 +6,7 @@
 void main(void) {
     Primitive prim = load_primitive(gl_InstanceID);
     Image image = fetch_image(prim.prim_index);
+    ResourceRect res = fetch_resource_rect(prim.user_data.x);
 
 #ifdef WR_FEATURE_TRANSFORM
     TransformVertexInfo vi = write_transform_vertex(prim.local_rect,
@@ -28,8 +29,8 @@ void main(void) {
 
     // vUv will contain how many times this image has wrapped around the image size.
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = image.st_rect.xy / texture_size;
-    vec2 st1 = image.st_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vTextureSize = st1 - st0;
     vTextureOffset = st0;

webrender/res/ps_text_run.vs.glsl

@@ -7,7 +7,9 @@ void main(void) {
     Primitive prim = load_primitive(gl_InstanceID);
     TextRun text = fetch_text_run(prim.prim_index);
     Glyph glyph = fetch_glyph(prim.sub_index);
-    vec4 local_rect = vec4(glyph.offset.xy, (glyph.uv_rect.zw - glyph.uv_rect.xy) / uDevicePixelRatio);
+    ResourceRect res = fetch_resource_rect(prim.user_data.x);
+
+    vec4 local_rect = vec4(glyph.offset.xy, (res.uv_rect.zw - res.uv_rect.xy) / uDevicePixelRatio);
 
 #ifdef WR_FEATURE_TRANSFORM
     TransformVertexInfo vi = write_transform_vertex(local_rect,
@@ -26,8 +28,8 @@ void main(void) {
 #endif
 
     vec2 texture_size = vec2(textureSize(sColor0, 0));
-    vec2 st0 = glyph.uv_rect.xy / texture_size;
-    vec2 st1 = glyph.uv_rect.zw / texture_size;
+    vec2 st0 = res.uv_rect.xy / texture_size;
+    vec2 st1 = res.uv_rect.zw / texture_size;
 
     vColor = text.color;
     vUv = mix(st0, st1, f);

webrender/src/device.rs

@@ -1366,6 +1366,11 @@ impl Device {
                 if u_data128 != -1 {
                     gl::uniform_1i(u_data128, TextureSampler::Data128    as i32);
                 }
+
+                let u_resource_rects = gl::get_uniform_location(program.id, "sResourceRects");
+                if u_resource_rects != -1 {
+                    gl::uniform_1i(u_resource_rects, TextureSampler::ResourceRects as i32);
+                }
             }
         }
     }

webrender/src/internal_types.rs

@@ -20,7 +20,7 @@ use std::sync::Arc;
 use tiling;
 use webrender_traits::{Epoch, ColorF, PipelineId};
 use webrender_traits::{ImageFormat, MixBlendMode, NativeFontHandle};
-use webrender_traits::{ScrollLayerId, WebGLCommand};
+use webrender_traits::{ExternalImageId, ScrollLayerId, WebGLCommand};
 
 // An ID for a texture that is owned by the
 // texture cache module. This can include atlases
@@ -45,9 +45,7 @@ pub enum SourceTexture {
     Invalid,
     TextureCache(CacheTextureId),
     WebGL(u32),                         // Is actually a gl::GLuint
-
-    // TODO(gw): Implement external image support via callback
-    //External(i32),
+    External(ExternalImageId),
 }
 
 pub enum GLContextHandleWrapper {
@@ -203,6 +201,7 @@ pub enum TextureSampler {
     Layers,
     RenderTasks,
     Geometry,
+    ResourceRects,
 }
 
 impl TextureSampler {

webrender/src/lib.rs

@@ -120,4 +120,5 @@ extern crate offscreen_gl_context;
 extern crate byteorder;
 extern crate rayon;
 
+pub use renderer::{ExternalImage, ExternalImageHandler};
 pub use renderer::{Renderer, RendererOptions};