/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at
http://mozilla.org/MPL/2.0/. */
// A very basic BlobImageRasterizer that can only render a checkerboard pattern.
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::Mutex;
use webrender::api::*;
use webrender::api::units::{BlobDirtyRect, BlobToDeviceTranslation, TileOffset};
use webrender::api::units::DeviceIntRect;
// Serialize/deserialize the blob.
pub fn serialize_blob(color: ColorU) -> Arc<Vec<u8>> {
Arc::new(vec![color.r, color.g, color.b, color.a])
}
fn deserialize_blob(blob: &[u8]) -> Result<ColorU, ()> {
let mut iter = blob.iter();
match (iter.next(), iter.next(), iter.next(), iter.next()) {
(Some(&r), Some(&g), Some(&b), Some(&a)) => Ok(ColorU::new(r, g, b, a)),
(Some(&a), None, None, None) => Ok(ColorU::new(a, a, a, a)),
_ => Err(()),
}
}
// perform floor((x * a) / 255. + 0.5) see "Three wrongs make a right" for derivation
fn premul(x: u8, a: u8) -> u8 {
let t = (x as u32) * (a as u32) + 128;
((t + (t >> 8)) >> 8) as u8
}
// This is the function that applies the deserialized drawing commands and generates
// actual image data.
fn render_blob(
color: ColorU,
descriptor: &BlobImageDescriptor,
tile: TileOffset,
_tile_size: TileSize,
dirty_rect: &BlobDirtyRect,
) -> BlobImageResult {
// Allocate storage for the result. Right now the resource cache expects the
// tiles to have have no stride or offset.
let buf_size = descriptor.rect.area() *
descriptor.format.bytes_per_pixel();
let mut texels = vec![0u8; (buf_size) as usize];
// Generate a per-tile pattern to see it in the demo. For a real use case it would not
// make sense for the rendered content to depend on its tile.
let tile_checker = (tile.x % 2 == 0) != (tile.y % 2 == 0);
let dirty_rect = dirty_rect.to_subrect_of(&descriptor.rect);
// We want the dirty rect local to the tile rather than the whole image.
let tx: BlobToDeviceTranslation = (-descriptor.rect.min.to_vector()).into();
let rasterized_rect = tx.transform_box(&dirty_rect);
for y in rasterized_rect.min.y .. rasterized_rect.max.y {
for x in rasterized_rect.min.x .. rasterized_rect.max.x {
// Apply the tile's offset. This is important: all drawing commands should be
// translated by this offset to give correct results with tiled blob images.
let x2 = x + descriptor.rect.min.x;
let y2 = y + descriptor.rect.min.y;
// Render a simple checkerboard pattern
let checker = if (x2 % 20 >= 10) != (y2 % 20 >= 10) {
1
} else {
0
};
// ..nested in the per-tile checkerboard pattern
let tc = if tile_checker { 0 } else { (1 - checker) * 40 };
match descriptor.format {
ImageFormat::BGRA8 => {
let a = color.a * checker + tc;
let pixel_offset = ((y * descriptor.rect.width() + x) * 4) as usize;
texels[pixel_offset ] = premul(color.b * checker + tc, a);
texels[pixel_offset + 1] = premul(color.g * checker + tc, a);
texels[pixel_offset + 2] = premul(color.r * checker + tc, a);
texels[pixel_offset + 3] = a;
}
ImageFormat::R8 => {
texels[(y * descriptor.rect.width() + x) as usize] = color.a * checker + tc;
}
_ => {
return Err(BlobImageError::Other(
format!("Unsupported image format {:?}", descriptor.format),
));
}
}
}
}
Ok(RasterizedBlobImage {
data: Arc::new(texels),
rasterized_rect,
})
}
/// See rawtest.rs. We use this to test that blob images are requested the right
/// amount of times.
pub struct BlobCallbacks {
pub request: Box<dyn Fn(&[BlobImageParams]) + Send + 'static>,
}
impl BlobCallbacks {
pub fn new() -> Self {
BlobCallbacks { request: Box::new(|_|()) }
}
}
pub struct CheckerboardRenderer {
image_cmds: HashMap<BlobImageKey, (ColorU, TileSize)>,
callbacks: Arc<Mutex<BlobCallbacks>>,
}
impl CheckerboardRenderer {
pub fn new(callbacks: Arc<Mutex<BlobCallbacks>>) -> Self {
CheckerboardRenderer {
callbacks,
image_cmds: HashMap::new(),
}
}
}
impl BlobImageHandler for CheckerboardRenderer {
fn create_similar(&self) -> Box<dyn BlobImageHandler> {
Box::new(CheckerboardRenderer::new(Arc::clone(&self.callbacks)))
}
fn add(&mut self, key: BlobImageKey, cmds: Arc<BlobImageData>,
_visible_rect: &DeviceIntRect, tile_size: TileSize) {
self.image_cmds
.insert(key, (deserialize_blob(&cmds[..]).unwrap(), tile_size));
}
fn update(&mut self, key: BlobImageKey, cmds: Arc<BlobImageData>,
_visible_rect: &DeviceIntRect, _dirty_rect: &BlobDirtyRect) {
// Here, updating is just replacing the current version of the commands with
// the new one (no incremental updates).
self.image_cmds.get_mut(&key).unwrap().0 = deserialize_blob(&cmds[..]).unwrap();
}
fn delete(&mut self, key: BlobImageKey) {
self.image_cmds.remove(&key);
}
fn delete_font(&mut self, _key: FontKey) {}
fn delete_font_instance(&mut self, _key: FontInstanceKey) {}
fn clear_namespace(&mut self, _namespace: IdNamespace) {}
fn prepare_resources(
&mut self,
_services: &dyn BlobImageResources,
requests: &[BlobImageParams],
) {
if !requests.is_empty() {
(self.callbacks.lock().unwrap().request)(requests);
}
}
fn create_blob_rasterizer(&mut self) -> Box<dyn AsyncBlobImageRasterizer> {
Box::new(Rasterizer { image_cmds: self.image_cmds.clone() })
}
fn enable_multithreading(&mut self, _enable: bool) {}
}
struct Command {
request: BlobImageRequest,
color: ColorU,
descriptor: BlobImageDescriptor,
tile: TileOffset,
tile_size: TileSize,
dirty_rect: BlobDirtyRect,
}
struct Rasterizer {
image_cmds: HashMap<BlobImageKey, (ColorU, TileSize)>,
}
impl AsyncBlobImageRasterizer for Rasterizer {
fn rasterize(
&mut self,
requests: &[BlobImageParams],
_low_priority: bool,
_tile_pool: &mut BlobTilePool,
) -> Vec<(BlobImageRequest, BlobImageResult)> {
let requests: Vec<Command> = requests.iter().map(
|item| {
let (color, tile_size) = self.image_cmds[&item.request.key];
Command {
request: item.request,
color,
tile_size,
tile: item.request.tile,
descriptor: item.descriptor,
dirty_rect: item.dirty_rect,
}
}
).collect();
requests.iter().map(|cmd| {
(cmd.request, render_blob(cmd.color, &cmd.descriptor, cmd.tile, cmd.tile_size, &cmd.dirty_rect))
}).collect()
}
}
