fix(canvas): transform and sample drawImage sources natively

This commit is contained in:
ldm0
2026-11-21 20:03:33 +08:00
parent 83ea53749c
commit 980fc70c26
11 changed files with 485 additions and 92 deletions
+20 -19
View File
@@ -339,25 +339,26 @@ impl PixelBuffer {
Some(())
}
/// Sample an image drawing before destination-format quantization. Shadow
/// generation applies globalAlpha and the shadow color to this alpha once.
pub fn sample_image(
&self,
blit: DrawImageBlit,
filter: ScaleFilter,
x: f64,
y: f64,
) -> [f32; 4] {
let sx = blit.source_x + (x - blit.dest_x) * blit.source_width / blit.dest_width;
let sy = blit.source_y + (y - blit.dest_y) * blit.source_height / blit.dest_height;
if !(blit.dest_x.floor()..(blit.dest_x + blit.dest_width).ceil()).contains(&x)
|| !(blit.dest_y.floor()..(blit.dest_y + blit.dest_height).ceil()).contains(&y)
|| !(0.0..f64::from(self.width)).contains(&sx)
|| !(0.0..f64::from(self.height)).contains(&sy)
{
/// Sample premultiplied pixels at image coordinates, where texel centers
/// are at half-integers. Filtering clamps to the full image's edges, not
/// to a drawImage source crop, without quantizing an intermediate surface.
pub fn sample_texel(&self, x: f64, y: f64, filter: ScaleFilter) -> [f32; 4] {
if self.width == 0 || self.height == 0 || x.is_nan() || y.is_nan() {
return [0.0; 4];
}
self.filtered_pixel(sx, sy, filter)
match filter {
ScaleFilter::Nearest => self.filtered_pixel(
// A point exactly between texel centers selects the lower
// coordinate, matching the existing Canvas nearest tie rule.
(x.ceil() - 1.0).clamp(0.0, f64::from(self.width - 1)),
(y.ceil() - 1.0).clamp(0.0, f64::from(self.height - 1)),
filter,
),
ScaleFilter::Bilinear => self.sample_bilinear(
(x - 0.5).clamp(0.0, f64::from(self.width - 1)),
(y - 0.5).clamp(0.0, f64::from(self.height - 1)),
),
}
}
fn filtered_pixel(&self, x: f64, y: f64, filter: ScaleFilter) -> [f32; 4] {
@@ -638,7 +639,7 @@ impl PixelBuffer {
coverage: &[u8],
clip: Option<&[u8]>,
operation: CompositeOperation,
source: &impl PixelSource,
source: &(impl PixelSource + ?Sized),
) -> Option<()> {
if clip.is_some_and(|mask| mask.len() != coverage.len()) {
return None;
@@ -689,7 +690,7 @@ impl PixelBuffer {
&mut self,
clip: Option<&[u8]>,
operation: CompositeOperation,
source: &impl PixelSource,
source: &(impl PixelSource + ?Sized),
) -> Option<()> {
if clip.is_some_and(|mask| Some(mask.len()) != crate::byte_len(self.width, self.height)) {
return None;
@@ -67,6 +67,7 @@ mod drawing;
mod drawing_state;
mod helpers;
mod image_bitmap;
mod image_paint;
mod objects;
mod offscreen;
mod path;
@@ -1,11 +1,12 @@
use super::{CANVAS_CONTEXT_IMAGE_SMOOTHING_ENABLED_SLOT, context_bool_slot};
use crate::context_bootstrap::canvas::{
backing_store::canvas_owner_from_context,
image_paint::CanvasImagePaint,
image_source::{CanvasImageSource, image_source_image as source_pixels},
};
use crate::context_bootstrap::image_data::ImageDataPixelFormat;
use crate::{context_bootstrap::throw_dom_exception_value, web_api_interfaces, webidl};
use moli_canvas::{DrawImageBlit, ScaleFilter};
use moli_canvas::ScaleFilter;
use moli_webapi_declare::{WebApiFunctionTemplate, web_api_object_target};
macro_rules! draw_image_declaration {
@@ -113,18 +114,12 @@ impl Coordinates {
coordinates.iter().all(|coordinate| coordinate.is_finite())
}
fn blit(self, width: u32, height: u32) -> Option<DrawImageBlit> {
fn rectangles(self, width: u32, height: u32) -> ([f64; 4], [f64; 4]) {
let (width, height) = (f64::from(width), f64::from(height));
match self {
Self::Natural([dx, dy]) => {
DrawImageBlit::new(0.0, 0.0, width, height, dx, dy, width, height)
}
Self::Scaled([dx, dy, dw, dh]) => {
DrawImageBlit::new(0.0, 0.0, width, height, dx, dy, dw, dh)
}
Self::Cropped([sx, sy, sw, sh, dx, dy, dw, dh]) => {
DrawImageBlit::new(sx, sy, sw, sh, dx, dy, dw, dh)
}
Self::Natural([dx, dy]) => ([0.0, 0.0, width, height], [dx, dy, width, height]),
Self::Scaled([dx, dy, dw, dh]) => ([0.0, 0.0, width, height], [dx, dy, dw, dh]),
Self::Cropped([sx, sy, sw, sh, dx, dy, dw, dh]) => ([sx, sy, sw, sh], [dx, dy, dw, dh]),
}
}
}
@@ -192,9 +187,7 @@ fn canvas_context_draw_image_callback<'s>(
if !image.origin_clean {
super::super::backing_store::set_canvas_origin_clean(scope, canvas, false);
}
let Some(blit) = coordinates.blit(width, height) else {
return;
};
let (source_rectangle, destination_rectangle) = coordinates.rectangles(width, height);
let filter = if context_bool_slot(scope, context, CANVAS_CONTEXT_IMAGE_SMOOTHING_ENABLED_SLOT)
.unwrap_or(true)
{
@@ -203,6 +196,32 @@ fn canvas_context_draw_image_callback<'s>(
ScaleFilter::Nearest
};
let alpha = super::context_global_alpha(scope, context) as f32;
let space =
crate::context_bootstrap::canvas::settings::Canvas2dSettings::for_context(scope, context)
.color_space;
let format = if image.color_space != space {
ImageDataPixelFormat::RgbaFloat16
} else {
ImageDataPixelFormat::from_native(image.pixels.format())
};
let source_alpha_mode = image.pixels.alpha_mode();
let Some(image) = image.convert(space, format, source_alpha_mode) else {
crate::util::throw_range_error(scope, "Unable to allocate drawImage color conversion.");
return;
};
let transform = crate::context_bootstrap::canvas::state::canvas_path_state(scope, context)
.borrow()
.transform();
let Some(paint) = CanvasImagePaint::new(
&image.pixels,
source_rectangle,
destination_rectangle,
transform,
filter,
alpha,
) else {
return;
};
let drawing =
crate::context_bootstrap::canvas::drawing::CanvasDrawingState::for_context(scope, context);
crate::context_bootstrap::canvas::clipping::draw_with_clip(
@@ -210,36 +229,24 @@ fn canvas_context_draw_image_callback<'s>(
context,
canvas,
|target, clip| {
let format = if image.color_space != target.color_space {
ImageDataPixelFormat::RgbaFloat16
} else {
ImageDataPixelFormat::from_native(image.pixels.format())
};
if let Some(image) =
image.convert(target.color_space, format, target.pixels.alpha_mode())
{
drawing.composite_shadow(
&mut target.pixels,
clip,
crate::context_bootstrap::canvas::drawing::ShadowSource::Image {
pixels: &image.pixels,
blit,
filter,
alpha,
},
)?;
target
.pixels
.draw_image_with_operation(
&image.pixels,
blit,
filter,
alpha,
clip,
drawing.operation,
)
.expect("validated image and clipping dimensions");
let width = target.pixels.width();
let height = target.pixels.height();
if width == 0 || height == 0 {
return Ok(());
}
let coverage = paint.coverage(width, height)?;
drawing.composite_shadow(
&mut target.pixels,
clip,
crate::context_bootstrap::canvas::drawing::ShadowSource::Path {
path: paint.path(),
paint: &paint,
},
)?;
target
.pixels
.composite_source(&coverage.rgba, clip, drawing.operation, &paint)
.expect("validated image and clipping dimensions");
Ok(())
},
);
@@ -1,8 +1,10 @@
//! Canvas drawing-model state and shadows, before the final bitmap clip.
use super::{context2d, style_state::CanvasPaint};
use moli_canvas::{CompositeOperation, DrawImageBlit, PixelBuffer, PixelSource, ScaleFilter};
use moli_layout::{PaintColor, PaintFragment, PaintSnapshot, PaintViewport};
use super::{context2d, path::Canvas2dPathState};
use moli_canvas::{CompositeOperation, PixelBuffer, PixelSource};
use moli_layout::{
LayoutTransform2D, PaintColor, PaintFillRule, PaintFragment, PaintSnapshot, PaintViewport,
};
use moli_paint::PaintError;
// HTML explicitly permits an implementation limit on the Gaussian sigma.
@@ -24,20 +26,18 @@ pub(super) struct CanvasDrawingState {
pub(super) enum ShadowSource<'a> {
Geometry {
fragment: &'a PaintFragment,
paint: &'a CanvasPaint,
paint: &'a dyn PixelSource,
},
Path {
path: &'a Canvas2dPathState,
paint: &'a dyn PixelSource,
},
Text {
text: &'a str,
font: &'a str,
x: f64,
y: f64,
paint: &'a CanvasPaint,
},
Image {
pixels: &'a PixelBuffer,
blit: DrawImageBlit,
filter: ScaleFilter,
alpha: f32,
paint: &'a dyn PixelSource,
},
}
@@ -266,22 +266,24 @@ impl ShadowSource<'_> {
);
(coverage, *paint)
}
Self::Image {
pixels,
blit,
filter,
alpha,
} => {
let mut blit = *blit;
blit.dest_x -= region.origin[0];
blit.dest_y -= region.origin[1];
return Ok((0..height)
.flat_map(|y| (0..width).map(move |x| (x, y)))
.map(|(x, y)| {
(pixels.sample_image(blit, *filter, f64::from(x), f64::from(y))[3] * alpha)
.clamp(0.0, 1.0)
})
.collect());
Self::Path { path, paint } => {
let path = path.transformed_snapshot(LayoutTransform2D::new([
1.0,
0.0,
0.0,
1.0,
-region.origin[0],
-region.origin[1],
]));
let raster = moli_paint::raster_canvas_clip_mask(
width,
height,
&[moli_paint::CanvasClip {
path: path.clip_paint_path(width, height)?,
fill_rule: PaintFillRule::NonZero,
}],
)?;
(raster.rgba, *paint)
}
};
Ok(coverage
@@ -0,0 +1,185 @@
//! Native drawImage rectangle mapping, transformed coverage and image sampling.
use super::path::{
Canvas2dPathState,
coordinates::{NativeAffine, Point, Scalar},
};
use moli_canvas::{AlphaMode, PixelBuffer, PixelSource, ScaleFilter};
use moli_layout::{LayoutTransform2D, PaintFillRule};
#[derive(Clone, Copy)]
struct ImageRect {
origin: Point,
width: Scalar,
height: Scalar,
}
impl ImageRect {
fn new([x, y, width, height]: [f64; 4]) -> Option<Self> {
if width == 0.0 || height == 0.0 {
return None;
}
let mut origin = Point::new(x, y);
let mut width = Scalar::new(width);
let mut height = Scalar::new(height);
if width < Scalar::ZERO {
origin.x = origin.x + width;
width = -width;
}
if height < Scalar::ZERO {
origin.y = origin.y + height;
height = -height;
}
Some(Self {
origin,
width,
height,
})
}
fn transformed_corners(self, matrix: kurbo::Affine, offset: Point) -> [Point; 4] {
let origin = self.origin.transform(matrix);
let [a, b, c, d, _, _] = matrix.as_coeffs().map(Scalar::new);
let origin = Point {
x: origin.x + a * offset.x + c * offset.y,
y: origin.y + b * offset.x + d * offset.y,
};
let across = Point {
x: a * self.width,
y: b * self.width,
};
let down = Point {
x: c * self.height,
y: d * self.height,
};
[
origin,
Point {
x: origin.x + across.x,
y: origin.y + across.y,
},
Point {
x: origin.x + across.x + down.x,
y: origin.y + across.y + down.y,
},
Point {
x: origin.x + down.x,
y: origin.y + down.y,
},
]
}
}
pub(super) struct CanvasImagePaint<'a> {
pixels: &'a PixelBuffer,
path: Canvas2dPathState,
inverse: NativeAffine,
source: ImageRect,
destination: ImageRect,
filter: ScaleFilter,
alpha: f32,
}
impl<'a> CanvasImagePaint<'a> {
pub(super) fn new(
pixels: &'a PixelBuffer,
source: [f64; 4],
destination: [f64; 4],
transform: LayoutTransform2D,
filter: ScaleFilter,
alpha: f32,
) -> Option<Self> {
let matrix = kurbo::Affine::new(transform.coefficients);
let inverse = NativeAffine::inverse(matrix)?;
let source = ImageRect::new(source)?;
let destination = ImageRect::new(destination)?;
let left = if source.origin.x < Scalar::ZERO {
Scalar::ZERO
} else {
source.origin.x
};
let top = if source.origin.y < Scalar::ZERO {
Scalar::ZERO
} else {
source.origin.y
};
let image_width = Scalar::new(f64::from(pixels.width()));
let image_height = Scalar::new(f64::from(pixels.height()));
let source_width = source.width - (left - source.origin.x);
let source_height = source.height - (top - source.origin.y);
let width = if source_width > image_width - left {
image_width - left
} else {
source_width
};
let height = if source_height > image_height - top {
image_height - top
} else {
source_height
};
if width <= Scalar::ZERO || height <= Scalar::ZERO {
return None;
}
// Clip source and destination proportionally before applying the CTM.
// Native scalars retain finite-input sums and products beyond f64.
let clipped = ImageRect {
origin: destination.origin,
width: width * destination.width / source.width,
height: height * destination.height / source.height,
};
let offset = Point {
x: (left - source.origin.x) * destination.width / source.width,
y: (top - source.origin.y) * destination.height / source.height,
};
let path =
Canvas2dPathState::from_closed_polygon(clipped.transformed_corners(matrix, offset));
Some(Self {
pixels,
path,
inverse,
source,
destination,
filter,
alpha,
})
}
pub(super) fn path(&self) -> &Canvas2dPathState {
&self.path
}
pub(super) fn coverage(
&self,
width: u32,
height: u32,
) -> Result<moli_paint::RasterImage, moli_paint::PaintError> {
moli_paint::raster_canvas_clip_mask(
width,
height,
&[moli_paint::CanvasClip {
path: self.path.clip_paint_path(width, height)?,
fill_rule: PaintFillRule::NonZero,
}],
)
}
}
impl PixelSource for CanvasImagePaint<'_> {
fn alpha_mode(&self) -> AlphaMode {
AlphaMode::Premultiplied
}
fn sample(&self, x: f64, y: f64) -> [f32; 4] {
if self.alpha == 0.0 {
return [0.0; 4];
}
let local = self
.inverse
.map_relative(Point::new(x + 0.5, y + 0.5), self.destination.origin);
let x = self.source.origin.x + local.x * self.source.width / self.destination.width;
let y = self.source.origin.y + local.y * self.source.height / self.destination.height;
self.pixels
.sample_texel(x.lossy(), y.lossy(), self.filter)
.map(|channel| channel * self.alpha)
}
}
@@ -97,6 +97,18 @@ impl Default for Canvas2dPathState {
const TWO_PI: f64 = std::f64::consts::TAU;
impl Canvas2dPathState {
/// An owned bitmap-coordinate polygon, without narrowing native endpoints
/// or changing the context's current default path.
pub(super) fn from_closed_polygon(points: [Point; 4]) -> Self {
let mut state = Self::default();
state.move_to_canvas(points[0]);
for point in points[1..].iter().copied() {
state.line_to_canvas(point);
}
state.close_path();
state
}
pub(super) fn from_svg(raw: &str) -> Self {
let mut state = Self::default();
for element in moli_svg::parse_path_data(raw).elements() {
@@ -343,10 +343,20 @@ impl NativeAffine {
}
pub(in crate::context_bootstrap::canvas) fn map(self, point: Point) -> Point {
self.map_relative(point, Point::ZERO)
}
/// Subtract the local origin before adding pixel-sized variable terms.
/// Adding a very large translation first would discard those terms.
pub(in crate::context_bootstrap::canvas) fn map_relative(
self,
point: Point,
origin: Point,
) -> Point {
let [a, b, c, d, e, f] = self.0;
Point {
x: a * point.x + c * point.y + e,
y: b * point.x + d * point.y + f,
x: a * point.x + c * point.y + (e - origin.x),
y: b * point.x + d * point.y + (f - origin.y),
}
}
}
@@ -0,0 +1,143 @@
(owner, callee, kind, label, videoFrameExposed = true) => {
const rows = [], colors = [[255,0,0,255],[0,255,0,255],[0,0,255,255],[255,255,255,255]];
const assert = (ok, message='assertion failed') => {if (!ok) throw Error(message);};
const check = (name, run) => {
try {run(); rows.push({name:label+': '+name,passed:true});}
catch (error) {rows.push({name:label+': '+name,passed:false,error:String(error)});}
};
const proto = callee[kind==='element'?'CanvasRenderingContext2D':'OffscreenCanvasRenderingContext2D'].prototype;
const call = (ctx,name,...args) => Reflect.apply(proto[name],ctx,args);
const make = () => {
const canvas = kind==='element'?owner.document.createElement('canvas'):new owner.OffscreenCanvas(8,8);
canvas.width=8;canvas.height=8;
const ctx=canvas.getContext('2d');ctx.imageSmoothingEnabled=false;
return [canvas,ctx];
};
const source = () => {
const canvas=new owner.OffscreenCanvas(2,2);
canvas.getContext('2d').putImageData(new owner.ImageData(new owner.Uint8ClampedArray(colors.flat()),2,2),0,0);
return canvas;
};
const pixel = (ctx,x,y) => Array.from(call(ctx,'getImageData',x,y,1,1).data);
const near = (actual,expected,tolerance=2) => assert(actual.every((v,i)=>Math.abs(v-expected[i])<=tolerance),actual+' != '+expected);
const red = ctx => {ctx.fillStyle='red';call(ctx,'fillRect',0,0,8,8);};
const matrices = [
['identity',[1,0,0,1,0,0]], ['translation',[1,0,0,1,3,2]],
['scale',[2,0,0,2,1,1]], ['reflection',[-1,0,0,1,5,1]],
['rotation',[0,1,-1,0,5,1]], ['x shear',[1,0,1,1,1,1]],
['y shear',[1,1,0,1,1,1]], ['anisotropic scale',[3,0,0,2,1,1]],
];
const palette = (matrix,args) => {
const [,ctx]=make();call(ctx,'setTransform',...matrix);call(ctx,'drawImage',source(),...args);
const [a,b,c,d,e,f]=matrix,det=a*d-b*c;
const local = (x,y) => [(d*(x-e)-c*(y-f))/det,(-b*(x-e)+a*(y-f))/det];
let inside=0,checked=0;
for(let y=0;y<8;y++)for(let x=0;x<8;x++) {
const corners=[[x,y],[x+1,y],[x+1,y+1],[x,y+1]].map(p=>local(...p));
if(corners.every(([x,y])=>x>=0&&x<=2&&y>=0&&y<=2)) {
const [sx,sy]=local(x+0.5,y+0.5);
const indices = value => (Number.isInteger(value)?[value-1,value]:[Math.floor(value)]).map(v=>Math.max(0,Math.min(1,v)));
const actual=pixel(ctx,x,y),candidates=indices(sy).flatMap(y=>indices(sx).map(x=>colors[y*2+x]));
// Nearest-neighbor ties on an exact texel boundary can select
// either neighbor. Geometry and all untied samples stay exact.
assert(candidates.some(expected=>actual.every((v,i)=>Math.abs(v-expected[i])<=2)),actual+' is not a nearest sample');inside++;checked++;
} else if([0,1].some(axis=>corners.every(p=>p[axis]<=0)||corners.every(p=>p[axis]>=2))) {
near(pixel(ctx,x,y),[0,0,0,0]);checked++;
}
}
assert(inside>0&&checked>inside,'matrix did not check inside and outside pixels');
};
for(const [name,matrix] of matrices)for(const [overload,args] of [[3,[0,0]],[5,[0,0,2,2]],[9,[0,0,2,2,0,0,2,2]]])
check(name+' '+overload+' arguments',()=>palette(matrix,args));
for(const [name,args] of [
['negative destination width',[2,0,-2,2]],['negative destination height',[0,2,2,-2]],
['negative source width',[2,0,-2,2,0,0,2,2]],['negative source and destination',[2,2,-2,-2,2,2,-2,-2]],
])check(name,()=>palette([1,0,0,1,0,0],args));
check('source clipping proportionally clips transformed destination',()=>{
const [,ctx]=make();call(ctx,'translate',1,1);call(ctx,'drawImage',source(),-1,0,3,2,0,0,6,4);
near(pixel(ctx,1,1),[0,0,0,0]);near(pixel(ctx,3,1),colors[0]);near(pixel(ctx,5,1),colors[1]);
near(pixel(ctx,3,3),colors[2]);near(pixel(ctx,5,3),colors[3]);
});
check('tiny nonzero source width is retained when scaled up',()=>{
const [,ctx]=make();call(ctx,'drawImage',source(),0.5,0,1e-200,2,0,0,4,4);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,3,0),colors[0]);near(pixel(ctx,0,3),colors[2]);
});
for(const scale of [1e200,1e-200])check('finite extreme scale '+scale,()=>{
const [,ctx]=make();call(ctx,'setTransform',scale,0,0,scale,0,0);
call(ctx,'drawImage',source(),0,0,4/scale,4/scale);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,3,0),colors[1]);near(pixel(ctx,0,3),colors[2]);near(pixel(ctx,3,3),colors[3]);
});
check('large translation cancellation retains pixel-sized destination',()=>{
const [,ctx]=make();call(ctx,'setTransform',1e200,0,0,1e200,-1e200,-1e200);
call(ctx,'drawImage',source(),1,1,4e-200,4e-200);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,3,0),colors[1]);near(pixel(ctx,0,3),colors[2]);near(pixel(ctx,3,3),colors[3]);
});
check('copy composes transparent source outside transformed destination',()=>{
const [,ctx]=make();red(ctx);ctx.globalCompositeOperation='copy';call(ctx,'translate',20,0);call(ctx,'drawImage',source(),0,0);
near(pixel(ctx,0,0),[0,0,0,0]);near(pixel(ctx,7,7),[0,0,0,0]);
});
check('singular CTM does not compose',()=>{
const [,ctx]=make();red(ctx);ctx.globalCompositeOperation='copy';call(ctx,'scale',0,1);call(ctx,'drawImage',source(),0,0);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,7,7),colors[0]);
});
check('completely clipped source rectangle does not compose',()=>{
const [,ctx]=make();red(ctx);ctx.globalCompositeOperation='copy';call(ctx,'drawImage',source(),10,10,2,2,0,0,2,2);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,7,7),colors[0]);
});
for(const args of [[0,0,0,2],[0,0,2,0],[0,0,0,2,0,0,2,2]])check('zero rectangle '+args.join(','),()=>{
const [,ctx]=make();red(ctx);ctx.globalCompositeOperation='copy';call(ctx,'drawImage',source(),...args);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,7,7),colors[0]);
});
check('shadow follows transformed image with device-space offset',()=>{
const [,ctx]=make();ctx.shadowColor='blue';ctx.shadowOffsetX=-3;call(ctx,'setTransform',2,0,0,2,4,4);call(ctx,'drawImage',source(),0,0);
near(pixel(ctx,1,4),[0,0,255,255]);near(pixel(ctx,4,4),colors[0]);
});
check('source clip does not remove a transformed image shadow',()=>{
const [,ctx]=make();call(ctx,'rect',0,0,2,8);call(ctx,'clip');ctx.shadowColor='blue';ctx.shadowOffsetX=-3;
call(ctx,'setTransform',2,0,0,2,4,4);call(ctx,'drawImage',source(),0,0);
near(pixel(ctx,1,4),[0,0,255,255]);near(pixel(ctx,4,4),[0,0,0,0]);
});
check('self draw snapshots before transformed copy',()=>{
const [canvas,ctx]=make();ctx.fillStyle='red';call(ctx,'fillRect',0,0,2,2);ctx.globalCompositeOperation='copy';
call(ctx,'setTransform',-1,0,0,1,4,0);call(ctx,'drawImage',canvas,0,0);
near(pixel(ctx,0,0),[0,0,0,0]);near(pixel(ctx,3,0),colors[0]);
});
check('numeric conversions precede CTM snapshot',()=>{
const [,ctx]=make();call(ctx,'drawImage',source(),{valueOf(){call(ctx,'translate',4,3);return 0;}},0);
near(pixel(ctx,4,3),colors[0]);near(pixel(ctx,0,0),[0,0,0,0]);
});
check('conversion exceptions do not paint',()=>{
const [,ctx]=make();red(ctx);const sentinel={};let caught;
try{call(ctx,'drawImage',source(),{valueOf(){call(ctx,'translate',4,3);return 0;}},{valueOf(){throw sentinel;}});}catch(error){caught=error;}
assert(caught===sentinel);near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,7,7),colors[0]);
});
check('drawing does not change the current path',()=>{
const [,ctx]=make();call(ctx,'rect',6,6,2,2);call(ctx,'drawImage',source(),0,0);ctx.fillStyle='blue';call(ctx,'fill');
near(pixel(ctx,6,6),[0,0,255,255]);near(pixel(ctx,0,0),colors[0]);
});
check('source dimensions use native slots',()=>{
const [,ctx]=make(),image=source();
for(const key of ['width','height'])Object.defineProperty(image,key,{get(){throw Error('author '+key);}});
call(ctx,'translate',3,2);call(ctx,'drawImage',image,0,0);near(pixel(ctx,3,2),colors[0]);
});
check('HTMLCanvas source uses transformed native pixels',()=>{
const [,ctx]=make(),image=owner.document?owner.document.createElement('canvas'):new owner.OffscreenCanvas(2,2);
image.width=2;image.height=2;image.getContext('2d').putImageData(new owner.ImageData(new owner.Uint8ClampedArray(colors.flat()),2,2),0,0);
call(ctx,'translate',3,2);call(ctx,'drawImage',image,0,0);near(pixel(ctx,3,2),colors[0]);near(pixel(ctx,4,3),colors[3]);
});
check('VideoFrame exposure and transformed native pixels',()=>{
if(!videoFrameExposed) {assert(owner.VideoFrame===undefined,'VideoFrame is not exposed in this worker kind');return;}
const [,ctx]=make(),frame=new owner.VideoFrame(new owner.Uint8Array(colors.flat()),{format:'RGBA',codedWidth:2,codedHeight:2,timestamp:1});
try{call(ctx,'translate',3,2);call(ctx,'drawImage',frame,0,0);near(pixel(ctx,3,2),colors[0]);near(pixel(ctx,4,3),colors[3]);}finally{frame.close();}
});
check('bilinear sampling uses texel centers and full-image crop neighbors',()=>{
const [,ctx]=make();ctx.imageSmoothingEnabled=true;call(ctx,'drawImage',source(),0,0,1,1,0,0,4,1);
near(pixel(ctx,0,0),colors[0]);near(pixel(ctx,2,0),[223,32,0,255],3);near(pixel(ctx,3,0),[159,96,0,255],3);
});
check('transformed source obeys globalAlpha copy and final clip',()=>{
const [,ctx]=make();red(ctx);call(ctx,'rect',2,2,4,4);call(ctx,'clip');ctx.globalCompositeOperation='copy';ctx.globalAlpha=0.5;
call(ctx,'translate',4,2);call(ctx,'drawImage',source(),0,0);
near(pixel(ctx,5,2),[0,255,0,128]);near(pixel(ctx,3,3),[0,0,0,0]);near(pixel(ctx,0,0),colors[0]);
});
return rows;
}
@@ -0,0 +1,17 @@
use super::*;
#[test]
fn native_draw_image_transforms_crop_and_sample_across_realms() {
let mut vm = new_storage_page_task_executor_test_vm("https://canvas-draw-image.test/");
vm.eval("document.body.innerHTML='<iframe></iframe>';globalThis.drawImageRealms=[globalThis,document.querySelector('iframe').contentWindow];").unwrap();
vm.eval(&format!(
"const probe={};globalThis.drawImageChecks=[];for(let owner=0;owner<2;owner++)for(let callee=0;callee<2;callee++)for(const kind of ['element','offscreen'])drawImageChecks.push(...probe(drawImageRealms[owner],drawImageRealms[callee],kind,owner+'-'+callee+'-'+kind));",
include_str!("canvas_draw_image.js")
)).unwrap();
assert_eq!(vm.eval("drawImageChecks.length").unwrap(), "400");
assert_eq!(
vm.eval("JSON.stringify(drawImageChecks.filter(row=>!row.passed))")
.unwrap(),
"[]"
);
}
@@ -2307,6 +2307,7 @@ mod dom_token_list_native_receivers;
mod canvas_arguments;
mod canvas_compositing;
mod canvas_draw_image;
mod canvas_drawing_state;
mod canvas_fill_rect;
mod canvas_gradients;
@@ -24,6 +24,15 @@ async fn worker_canvas_shadows_preserve_unclipped_sources_and_ordered_compositin
assert_canvas_fixture_worker_kinds(source, 25).await;
}
#[tokio::test]
async fn worker_draw_image_transforms_crop_and_sample_across_global_kinds() {
let source = format!(
"const probe={};const rows=probe(globalThis,globalThis,'offscreen','worker',workerVideoFrameExposed);console.log(JSON.stringify({{total:rows.length,failures:rows.filter(row=>!row.passed)}}));",
include_str!("../../../script_vm/tests/canvas_draw_image.js")
);
assert_canvas_fixture_worker_kinds(source, 50).await;
}
async fn assert_canvas_fixture_worker_kinds(source: String, expected: u64) {
ensure_v8();
let storage_key = moli_storage_key::MoliStorageKey::new(
@@ -46,9 +55,14 @@ async fn assert_canvas_fixture_worker_kinds(source: String, expected: u64) {
scope_url: url::Url::parse("https://canvas-compositing.test/").unwrap(),
},
] {
let source = format!(
"const workerVideoFrameExposed={};\n{}",
matches!(&kind, super::super::WorkerGlobalKind::Dedicated { .. }),
source
);
let mut handle = spawn_test_worker_with_options(
WorkerSpawnOptions::new(
source.clone(),
source,
"https://canvas-compositing.test/worker.js".to_owned(),
)
.with_global_kind(kind),