Merge pull request #1918 from dotCooCoo/fix/metafile-report-drops

craft-metafile: report what the reader leaves out
This commit is contained in:
Dylan M. Taylor
2026-11-16 19:53:33 -05:00
committed by GitHub
11 changed files with 960 additions and 94 deletions
+19 -1
View File
@@ -33,7 +33,19 @@ Every item carries the clip it was drawn under: `region` (the GDI clip region as
`Arc<ClipPath>`). An item shows inside its region and inside each of its clip paths.
`Picture::skipped_records` counts records of a type the reader does not play, so a caller can say
that part of a file was not read.
that part of a file was not read. The other fields report what the reader left out or drew
differently:
| Field | Reports |
|---|---|
| `truncated` | The parse stopped at a limit that ends it (items, bytes kept, `SAVEDC` depth, clip paths), in the file or in an EMF+ metafile image drawn in it. |
| `dropped_images` | Images that were not read: bitmaps past a size, item, byte or decode limit or not decodable, EMF+ metafile images that do not parse or are nested too deep, and pattern or texture brushes whose bitmap was not read, a pen's brush included (counted when the brush or pen is created). An image with no pixels, or drawn from a source rectangle that selects none, is not counted. |
| `ignored_clips` | Clip changes not applied as the file asks: `SELECTCLIPPATH` with `RGN_OR`, `RGN_XOR` or `RGN_DIFF`, EMF+ clips combined with XOR, exclude or complement, EMF+ unions drawn as the rectangle around both areas, and EMF+ clips whose area stands in for the one the file gives (a path that is not one convex figure, drawn as its rectangle, or a region built with XOR, exclude or complement). A change that cannot alter the clip is not counted: an area whose figures all lie on a line (except in an EMF+ complement of a clip that encloses some area, which would empty it), `RGN_OR` on a clip that is still the whole surface, and a union whose rectangle is no larger than the union. |
| `unplayed_raster_ops` | Raster operations not played: bitmaps drawn as plain copies because their operation is not one of `SRCCOPY`, `SRCAND`, `SRCPAINT` and `SRCINVERT`, and operations without a source (such as `DSTINVERT` or `PATINVERT`) that are left out. |
An EMF+ metafile image adds its own counts, `skipped_records` included, once, the first time it is
drawn. A metafile image that the byte limit refuses is counted in `dropped_images`, and its own
counts are not added.
### Why this model
@@ -153,6 +165,12 @@ it never panics and never allocates from an unchecked count. Each limit has a te
| Writers: dashes cut from one stroke | 100,000 | The stroke is written solid. |
| Writers: segments from one curve | about 4,096 | The tolerance is raised. |
A limit that stops the parse sets `Picture::truncated`, and a bitmap, metafile image or pattern
brush whose pixels were not read is counted in `Picture::dropped_images`. These are not reported:
the limits that cut a path, a string, a clip region, a pen style or an EMF+ point list or gradient
short, items left out by the clipping and masking limits, and an EMF+ continued object whose pieces
never complete.
The tests parse every prefix of sample files, files with each byte replaced, and random bytes.
## What stays in the apps
+72 -3
View File
@@ -391,6 +391,14 @@ pub(crate) struct Canvas {
fig_start: P,
/// Records of a type the readers do not know.
pub skipped: u32,
/// Bitmaps a record asks to draw whose pixels were not read (see [`crate::Picture::dropped_images`]).
pub dropped_images: u32,
/// Clip changes not applied as the file asks (see [`crate::Picture::ignored_clips`]).
pub ignored_clips: u32,
/// Raster operations not played (see [`crate::Picture::unplayed_raster_ops`]).
pub unplayed_raster_ops: u32,
/// A nested picture drawn on this canvas stopped at a limit.
pub truncated_inside: bool,
}
impl Canvas {
@@ -426,6 +434,10 @@ impl Canvas {
arc_clockwise: false,
fig_start: (0.0, 0.0),
skipped: 0,
dropped_images: 0,
ignored_clips: 0,
unplayed_raster_ops: 0,
truncated_inside: false,
}
}
@@ -772,12 +784,25 @@ impl Canvas {
/// SELECTCLIPPATH: the bracketed path becomes part of the clip and the bracket is emptied.
/// RGN_AND clips to it inside the current clip; RGN_COPY replaces the clip with it. The modes
/// that add to or cut from the clip (RGN_OR, RGN_XOR, RGN_DIFF) leave the clip as it was. The
/// path uses the current fill mode. One clip path more than [`MAX_CLIP_PATHS`] stops the parse.
/// that add to or cut from the clip (RGN_OR, RGN_XOR, RGN_DIFF) leave the clip as it was, and a
/// path they would have used is counted in `ignored_clips`. The path uses the current fill
/// mode. One clip path more than [`MAX_CLIP_PATHS`] stops the parse.
pub fn select_clip_path(&mut self, mode: u32) {
let ops = std::mem::take(&mut self.path);
self.in_path = false;
if !matches!(mode, clip::RGN_AND | clip::RGN_COPY) {
// A path that encloses no area adds nothing to the clip and cuts nothing from it under
// these modes, and adding to a clip that is still the whole surface leaves it the whole
// surface.
let unclipped = self.clip.is_none() && self.clip_paths.is_empty();
let changes = match mode {
clip::RGN_OR => !unclipped,
clip::RGN_XOR | clip::RGN_DIFF => true,
_ => false,
};
if changes && crate::geom::encloses_area(&ops) {
self.ignore_clip();
}
return;
}
if mode == clip::RGN_COPY {
@@ -1189,17 +1214,30 @@ impl Canvas {
}
/// Fills a logical rectangle `[x, y, w, h]` for a source-less raster operation. PATCOPY uses the
/// brush (when solid); the others fill black or white. Other operations are not handled here.
/// brush (when solid); the others fill black or white. Other operations are not drawn; one that
/// takes no source (such as DSTINVERT) is counted in `unplayed_raster_ops`.
pub fn fill_rop(&mut self, [x, y, w, h]: [f64; 4], rop: u32) {
let rect = [x, y, x + w, y + h];
match rop {
PATCOPY => self.fill_brush_rect(rect),
BLACKNESS => self.fill_rect_with(rect, [0, 0, 0, 255]),
WHITENESS => self.fill_rect_with(rect, [255, 255, 255, 255]),
_ if !crate::dib::uses_source(rop) => self.unplayed_rop(),
_ => {}
}
}
/// Counts a raster operation the canvas does not play (see [`crate::Picture::unplayed_raster_ops`]).
pub fn unplayed_rop(&mut self) {
self.unplayed_raster_ops = self.unplayed_raster_ops.saturating_add(1);
}
/// Counts a clip change the canvas does not apply as the file asks (see
/// [`crate::Picture::ignored_clips`]).
pub fn ignore_clip(&mut self) {
self.ignored_clips = self.ignored_clips.saturating_add(1);
}
/// Draws `text` (one `dx` advance per character, or none) with the current font, colours and
/// alignment. The reference point is `at`, or the current position under TA_UPDATECP (which
/// then moves past the string). `rect` (logical `[l, t, r, b]`) is filled with the background
@@ -1297,7 +1335,38 @@ impl Canvas {
let (x0, x1) = (xs.iter().copied().fold(f64::INFINITY, f64::min), xs.iter().copied().fold(f64::NEG_INFINITY, f64::max));
let (y0, y1) = (ys.iter().copied().fold(f64::INFINITY, f64::min), ys.iter().copied().fold(f64::NEG_INFINITY, f64::max));
let dev = if xf[1] == 0.0 && xf[2] == 0.0 { dev } else { [x0, y0, x1 - x0, y1 - y0] };
let was_full = self.full;
self.push(Raw::Bitmap { rect: dev, xf, img, region: RawClip::default() });
// A bitmap the item or byte limit refuses is counted once, however many pieces a clip cuts it into.
if self.full && !was_full {
self.drop_image();
}
}
/// Draws a bitmap that a record asked to combine with raster operation `rop` (already applied by
/// `dib::prepare`). A kept bitmap whose operation is drawn as a plain copy is counted in
/// `unplayed_raster_ops`.
pub fn bitmap_rop(&mut self, rect: [f64; 4], img: Rgba, rop: u32) {
let before = self.items.len();
self.bitmap(rect, img);
if self.items.len() > before && crate::dib::copies_for(rop) {
self.unplayed_rop();
}
}
/// Counts a bitmap a record asked to draw that the reader could not keep (see
/// [`crate::Picture::dropped_images`]).
pub fn drop_image(&mut self) {
self.dropped_images = self.dropped_images.saturating_add(1);
}
/// Adds what a nested picture left out to this canvas's counts.
pub fn add_losses(&mut self, pic: &crate::Picture) {
self.dropped_images = self.dropped_images.saturating_add(pic.dropped_images);
self.ignored_clips = self.ignored_clips.saturating_add(pic.ignored_clips);
self.unplayed_raster_ops = self.unplayed_raster_ops.saturating_add(pic.unplayed_raster_ops);
self.skipped = self.skipped.saturating_add(pic.skipped_records);
self.truncated_inside |= pic.truncated;
}
}
+57
View File
@@ -13,6 +13,7 @@ const BI_PNG: u32 = 5;
const CORE_HEADER: usize = 12;
/// Most palette entries a DIB can carry (the colour table never exceeds 2^8).
const MAX_PALETTE: usize = 256;
const ROP_SRCCOPY: u32 = 0x00CC_0020;
const ROP_SRCAND: u32 = 0x0088_00C6;
const ROP_SRCPAINT: u32 = 0x00EE_0086;
const ROP_SRCINVERT: u32 = 0x0066_0046;
@@ -107,6 +108,17 @@ fn compression(info: Bytes) -> Option<u32> {
(info.u32(0)? >= 40).then(|| info.u32(16)).flatten().filter(|c| matches!(*c, BI_JPEG | BI_PNG))
}
/// The width and height a JPEG or PNG file's header gives, without decoding any pixel. Unlike
/// [`decode_compressed`] it takes any side, with the same cap on what the decoder allocates.
pub(crate) fn compressed_size(bytes: &[u8]) -> Option<(usize, usize)> {
let mut r = image::ImageReader::new(std::io::Cursor::new(bytes)).with_guessed_format().ok()?;
let mut limits = image::Limits::default();
limits.max_alloc = Some((MAX_PIXELS * 4) as u64);
r.limits(limits);
let (w, h) = r.into_dimensions().ok()?;
Some((w as usize, h as usize))
}
/// Decodes a JPEG or PNG file (the bits of a BI_JPEG or BI_PNG DIB, an EMF+ image) to top-down
/// RGBA. The size comes from the file's header first, so an image over the side or pixel cap is
/// refused before any pixel is decoded, and the decoder's own allocations are capped too.
@@ -193,6 +205,51 @@ pub(crate) fn decode_clip(info: Bytes, bits: Bytes, keep_alpha: bool, src: [i64;
Some((Rgba { w: ow, h: oh, px }, out))
}
/// The width, height and row order (true for bottom-up) a DIB's header gives, whatever its depth or
/// compression. A BI_JPEG or BI_PNG bitmap is measured by the image file in `bits`, as
/// [`decode_clip`] crops it, counted from the top. None when the header is not readable.
fn header_size(info: Bytes, bits: Option<Bytes>) -> Option<(usize, usize, bool)> {
match info.u32(0)? {
n if n as usize == CORE_HEADER => info.u16(4).zip(info.u16(6)).map(|(w, h)| (usize::from(w), usize::from(h), true)),
_ if compression(info).is_some() => bits.and_then(|b| compressed_size(b.0)).map(|(w, h)| (w, h, false)),
n if n >= 40 => info.i32(4).zip(info.i32(8)).and_then(|(w, h)| Some((usize::try_from(w).ok()?, h.unsigned_abs() as usize, h > 0))),
_ => None,
}
}
/// True when the header of `info` is readable and the source rectangle `src` (as [`decode_clip`]
/// takes it) covers none of the bitmap's pixels, or the bitmap has none: such a bitmap draws nothing,
/// so it is not counted as left out. The size comes from [`header_size`], so a bitmap the decoder
/// does not read is measured too.
pub(crate) fn crop_misses(info: Bytes, bits: Option<Bytes>, src: [i64; 4]) -> bool {
header_size(info, bits).is_some_and(|(w, h, bottom_up)| w == 0 || h == 0 || clip_rect(w, h, bottom_up, src, [0.0, 0.0, 1.0, 1.0]).is_none())
}
/// True when a DIB's header is readable and gives it no pixels.
pub(crate) fn has_no_pixels(info: Bytes, bits: Option<Bytes>) -> bool {
header_size(info, bits).is_some_and(|(w, h, _)| w == 0 || h == 0)
}
/// True when a `w` x `h` top-down image has no pixels, or the source rectangle `src` (as
/// [`clip_blit`] takes it) covers none of them.
pub(crate) fn src_misses(w: usize, h: usize, src: [i64; 4]) -> bool {
w == 0 || h == 0 || clip_rect(w, h, false, src, [0.0, 0.0, 1.0, 1.0]).is_none()
}
/// Whether a ternary raster operation reads the source bitmap. Its index byte (bits 16 to 23) is the
/// operation's truth table over pattern, source and destination bits; the source does not matter
/// when the table is the same with the source bit set and clear.
pub(crate) fn uses_source(rop: u32) -> bool {
let table = (rop >> 16) & 0xFF;
((table >> 2) ^ table) & 0x33 != 0
}
/// Whether a bitmap drawn with raster operation `rop` is drawn as a plain copy without being one:
/// [`prepare`] plays SRCCOPY, SRCAND, SRCPAINT and SRCINVERT, and copies the source for every other.
pub(crate) fn copies_for(rop: u32) -> bool {
!matches!(rop, ROP_SRCCOPY | ROP_SRCAND | ROP_SRCPAINT | ROP_SRCINVERT)
}
/// Decodes a whole DIB (rows top-down); see [`decode_clip`].
pub(crate) fn decode(info: Bytes, bits: Bytes, keep_alpha: bool) -> Option<Rgba> {
decode_clip(info, bits, keep_alpha, [0, 0, 0, 0], [0.0, 0.0, 1.0, 1.0]).map(|(img, _)| img)
+33 -8
View File
@@ -357,14 +357,21 @@ fn create_brush(cv: &mut Canvas, r: Bytes) -> Option<()> {
/// EMR_CREATEDIBPATTERNBRUSHPT (94) and EMR_CREATEMONOBRUSH (93): handle, colour usage, then the
/// bitmap info and bits as offset/size pairs. A mono brush (or one whose palette holds indices,
/// DIB_PAL_COLORS) takes the text and background colours. An undecodable bitmap leaves the slot
/// empty.
/// empty, as does a tile past the side cap; either is counted as a dropped image unless it has no
/// pixels.
fn create_dib_brush(cv: &mut Canvas, r: Bytes, mono: bool) -> Option<()> {
let slot = r.u32(8)? as usize;
let usage = r.u32(12)?;
let (bo, bl) = (r.u32(16)? as usize, r.u32(20)? as usize);
let (po, pl) = (r.u32(24)? as usize, r.u32(28)? as usize);
let img = dib::decode(Bytes(r.slice(bo, bl)?), Bytes(r.slice(po, pl)?), false)?;
let b = Brush::pattern(img, mono || usage == 1)?;
let (info, bits) = (r.slice(bo, bl).map(Bytes), r.slice(po, pl).map(Bytes));
let brush = info.zip(bits).and_then(|(info, bits)| dib::decode(info, bits, false)).and_then(|img| Brush::pattern(img, mono || usage == 1));
let Some(b) = brush else {
if !info.is_some_and(|i| dib::has_no_pixels(i, bits)) {
cv.drop_image();
}
return None;
};
cv.add_object(Some(slot), Obj::Brush(b));
Some(())
}
@@ -500,17 +507,35 @@ fn set_dibits(cv: &mut Canvas, r: Bytes) -> Option<()> {
/// Decodes the bitmap at `at` = (offset of the bmi offset/length pair, offset of the bits pair), both
/// inside the record, and stretches the source rectangle `src` into `dst`. Both are `[x, y, w, h]`; a
/// non-positive source size means the whole bitmap. `blend` decides how it combines.
/// non-positive source size means the whole bitmap. `blend` decides how it combines. A record with
/// pixel bits whose bitmap cannot be read, or is past a limit, is counted as a dropped image. A raster
/// operation that takes no source fills the destination instead (see [`Canvas::fill_rop`]), with or
/// without bits.
fn blit(cv: &mut Canvas, r: Bytes, dst: [f64; 4], src: [f64; 4], at: (usize, usize), blend: Blend) -> Option<()> {
if let Blend::Rop(rop) = blend
&& !dib::uses_source(rop)
{
cv.fill_rop(dst, rop);
return Some(());
}
let (bo, bl) = (r.u32(at.0)? as usize, r.u32(at.0 + 4)? as usize);
let (po, pl) = (r.u32(at.1)? as usize, r.u32(at.1 + 4)? as usize);
if pl == 0 {
return None;
}
let info = Bytes(r.slice(bo, bl)?);
let pixels = Bytes(r.slice(po, pl)?);
let (mut img, dst) = dib::decode_clip(info, pixels, blend.per_pixel(), src.map(|v| v as i64), dst)?;
let src = src.map(|v| v as i64);
let (info, bits) = (r.slice(bo, bl).map(Bytes), r.slice(po, pl).map(Bytes));
let decoded = info.zip(bits).and_then(|(info, pixels)| dib::decode_clip(info, pixels, blend.per_pixel(), src, dst));
let Some((mut img, dst)) = decoded else {
if !info.is_some_and(|i| dib::crop_misses(i, bits, src)) {
cv.drop_image();
}
return None;
};
dib::prepare(&mut img, blend);
cv.bitmap(dst, img);
match blend {
Blend::Rop(rop) => cv.bitmap_rop(dst, img, rop),
Blend::Alpha { .. } => cv.bitmap(dst, img),
}
Some(())
}
+267 -56
View File
@@ -195,10 +195,17 @@ enum Obj {
},
Path(Vec<Op>),
Image(Arc<ImageData>),
/// An image object that could not be read or kept (past a limit, or in a form the reader does
/// not decode): drawing it counts a dropped image. The size of a bitmap, when its header gives one.
LostImage(Option<(usize, usize)>),
/// A texture brush whose image was not read or kept. It is counted as a dropped image when it is
/// stored, and the slot is left empty.
LostBrush,
Font(FontObj),
Format(Format),
/// A region's bounding rectangle `[l, t, r, b]` in world units; None is infinite.
Region(Area),
/// A region's bounding rectangle `[l, t, r, b]` in world units; None is infinite. The flag is set
/// when the area differs from the region the file describes (see [`region_node`]).
Region(Area, bool),
}
/// An object arriving in several records: its id, type, total size and the bytes so far.
@@ -227,6 +234,10 @@ pub(crate) struct Plus {
/// Convex device clip polygon; None is unclipped.
clip: Area,
objects: Vec<Option<Obj>>,
/// Whether the metafile image in each object slot has added its counts to the canvas.
reported: Vec<bool>,
/// Texture brushes not kept since the canvas last took the count.
lost_brushes: u32,
object_bytes: usize,
stack: Vec<Saved>,
partial: Option<Partial>,
@@ -244,6 +255,8 @@ impl Plus {
page: 1.0,
clip: None,
objects: vec![None; MAX_OBJECTS],
reported: vec![false; MAX_OBJECTS],
lost_brushes: 0,
object_bytes: 0,
stack: Vec::new(),
partial: None,
@@ -302,7 +315,13 @@ impl Plus {
return Some(());
}
let done = match typ {
0x4008 => self.object(flags, r, cv.used().saturating_add(self.clip_bytes())),
0x4008 => {
let done = self.object(flags, r, cv.used().saturating_add(self.clip_bytes()));
for _ in 0..std::mem::take(&mut self.lost_brushes) {
cv.drop_image();
}
done
}
0x4009 | 0x4013 | 0x401A..=0x401C | 0x4036 => self.record_image_text_region(cv, typ, flags, r),
0x4025..=0x4035 => self.record_state(cv, typ, flags, r),
0x4010..=0x4012 | 0x4016..=0x4019 => self.record_curve(cv, typ, flags, r),
@@ -463,7 +482,7 @@ impl Plus {
// FillRegion: the region's area (as the clip reads it).
0x4013 => {
let fill = self.brush_of(flags, r.u32(0)?)?;
let Some(Some(Obj::Region(Some(area)))) = self.objects.get(id).cloned() else { return None };
let Some(Some(Obj::Region(Some(area), _))) = self.objects.get(id).cloned() else { return None };
if area.len() < 3 {
return None;
}
@@ -471,14 +490,14 @@ impl Plus {
Some(())
}
0x401A => {
let img = self.image(id)?;
let dst = *rects(r, 24, 1, compressed)?.first()?;
let img = self.image(cv, id, r)?;
self.draw_image(cv, &img, r, [dst[0], dst[1], dst[2] - dst[0], dst[3] - dst[1]])
}
0x401B => {
let img = self.image(id)?;
let pts = points(r, 28, 3, compressed)?;
let (p0, p1, p2) = (*pts.first()?, *pts.get(1)?, *pts.get(2)?);
let img = self.image(cv, id, r)?;
// The destination parallelogram's top-left, top-right and bottom-left corners; a
// sheared or rotated one is drawn into its bounding rectangle's axes.
let dst = [p0.0, p0.1, p1.0 - p0.0 + (p2.0 - p0.0), p2.1 - p0.1 + (p1.1 - p0.1)];
@@ -523,16 +542,17 @@ impl Plus {
0x4032 => {
let [x, y, w, h] = floats::<4>(r, 0)?;
let area = map_area(Some(rect_poly([x, y, x + w, y + h])), mul(self.xf(), cv.device_affine()));
self.combine(flags, area)
self.combine(cv, flags, area, false)
}
0x4033 => {
let area = map_area(Some(area_of_ops(&self.path(id)?)), mul(self.xf(), cv.device_affine()));
self.combine(flags, area)
let (area, inexact) = area_of_ops(&self.path(id)?);
let area = map_area(Some(area), mul(self.xf(), cv.device_affine()));
self.combine(cv, flags, area, inexact)
}
0x4034 => {
let Some(Some(Obj::Region(reg))) = self.objects.get(id).cloned() else { return None };
let Some(Some(Obj::Region(reg, inexact))) = self.objects.get(id).cloned() else { return None };
let area = map_area(reg, mul(self.xf(), cv.device_affine()));
self.combine(flags, area)
self.combine(cv, flags, area, inexact)
}
0x4035 => {
let [dx, dy] = floats::<2>(r, 0)?;
@@ -571,14 +591,42 @@ impl Plus {
/// Combines a new clip area with the current one under the record's combine mode: replace,
/// intersect and union (as the rectangle around both). XOR, exclude and complement leave the
/// clip as it was.
fn combine(&mut self, flags: u16, new: Area) -> Option<()> {
self.clip = match (flags >> 8) & 0xF {
0 => new,
1 => area_intersect(self.clip.take(), new),
2 => area_union(self.clip.take(), new),
_ => self.clip.take(),
/// clip as it was. `inexact` says the new area already differs from what the file asks (see
/// [`region_node`]). The change is counted in the canvas's `ignored_clips` when the clip it
/// leaves can differ from what the file asks: an inexact area that replaces, cuts or widens the
/// clip, an intersection that ran out of work, a union whose rectangle is larger than the
/// union, an XOR, exclude or complement with an area that encloses some, and a complement of a
/// clip that encloses some.
fn combine(&mut self, cv: &mut Canvas, flags: u16, new: Area, inexact: bool) -> Option<()> {
let (clip, ignored) = match (flags >> 8) & 0xF {
0 => (new, inexact),
1 => {
let stand_in = intersect_inexact(&self.clip, false, &new, inexact);
let (out, cut_short) = area_intersect(self.clip.take(), new);
(out, stand_in || cut_short)
}
2 => {
let ignored = union_inexact(&self.clip, false, &new, inexact) || union_grows(&self.clip, &new);
(area_union(self.clip.take(), new), ignored)
}
// XOR changes the clip unless the new area is empty, exclude unless either is empty;
// complement replaces the clip with the part of the new area outside it, which differs
// from the clip unless both are empty.
mode @ 3..=5 => {
let new_area = inexact || encloses(&new);
let changes = match mode {
3 => new_area,
4 => new_area && encloses(&self.clip),
_ => new_area || encloses(&self.clip),
};
(self.clip.take(), changes)
}
_ => (self.clip.take(), false),
};
if ignored {
cv.ignore_clip();
}
self.clip = clip;
Some(())
}
@@ -626,11 +674,25 @@ impl Plus {
if let Some(old) = slot.take() {
self.object_bytes = self.object_bytes.saturating_sub(Self::obj_cost(&old));
}
if let Some(r) = self.reported.get_mut(id) {
*r = false;
}
if let Some(new_obj) = obj {
let cost = Self::obj_cost(&new_obj);
if self.object_bytes.saturating_add(cost).saturating_add(canvas_used) <= crate::MAX_BYTES {
if matches!(new_obj, Obj::LostBrush) {
self.lost_brushes = self.lost_brushes.saturating_add(1);
} else if self.object_bytes.saturating_add(cost).saturating_add(canvas_used) <= crate::MAX_BYTES {
self.object_bytes += cost;
*slot = Some(new_obj);
} else if let Obj::Image(img) = &new_obj {
// A metafile image refused here has its own counts dropped with it.
let size = match img.as_ref() {
ImageData::Bitmap(b) => Some((b.w, b.h)),
ImageData::Meta(_) => None,
};
*slot = Some(Obj::LostImage(size));
} else if let Obj::Brush(Fill::Texture { .. }) = new_obj {
self.lost_brushes = self.lost_brushes.saturating_add(1);
}
}
}
@@ -661,9 +723,27 @@ impl Plus {
}
}
fn image(&self, id: usize) -> Option<Arc<ImageData>> {
/// The image object `id` for the draw record `r`. A lost one gives None and is counted as a
/// dropped image, unless the record's source rectangle selects none of its pixels. A metafile
/// image adds what it left out to the canvas's counts the first time it is drawn.
fn image(&mut self, cv: &mut Canvas, id: usize, r: Bytes) -> Option<Arc<ImageData>> {
match self.objects.get(id)? {
Some(Obj::Image(img)) => Some(img.clone()),
Some(Obj::Image(img)) => {
if let (ImageData::Meta(pic), Some(reported)) = (img.as_ref(), self.reported.get_mut(id))
&& !*reported
{
cv.add_losses(pic);
*reported = true;
}
Some(img.clone())
}
Some(Obj::LostImage(size)) => {
let misses = size.zip(source_px(r)).is_some_and(|((w, h), src)| crate::dib::src_misses(w, h, src));
if !misses {
cv.drop_image();
}
None
}
_ => None,
}
}
@@ -685,13 +765,15 @@ impl Plus {
let img = match img {
ImageData::Bitmap(b) => b,
ImageData::Meta(pic) => {
self.painter().picture(cv, dst, pic);
// A nested picture without a size draws nothing; [`Self::image`] still reports what
// it left out.
if pic.width > 0.0 && pic.height > 0.0 {
self.painter().picture(cv, dst, pic);
}
return Some(());
}
};
let [sx, sy, sw, sh] = floats::<4>(r, 8)?;
let src = if r.u32(4)? == 2 { [sx, sy, sw, sh].map(|v| v.round().clamp(-1.0e9, 1.0e9) as i64) } else { [0; 4] };
let (part, dst) = crate::dib::clip_blit(img, src, dst)?;
let (part, dst) = crate::dib::clip_blit(img, source_px(r)?, dst)?;
self.painter().image(cv, dst, part);
Some(())
}
@@ -994,11 +1076,11 @@ fn matrix(r: Bytes, off: usize) -> Option<Xform> {
fn parse_object(kind: u16, r: Bytes) -> Option<Obj> {
match kind {
1 => brush(r, 0).map(Obj::Brush),
1 => brush(r, 0).map(Obj::Brush).or_else(|| lost_texture(r).then_some(Obj::LostBrush)),
2 => pen(r),
3 => path(r).map(Obj::Path),
4 => region(r),
5 => image(r).map(|i| Obj::Image(Arc::new(i))),
5 => Some(image(r).map_or_else(|| Obj::LostImage(bitmap_size(r)), |i| Obj::Image(Arc::new(i)))),
6 => font(r),
7 => Some(Obj::Format(Format { flags: r.u32(4)?, align: r.u32(12)?, line_align: r.u32(16)? })),
_ => None,
@@ -1099,7 +1181,11 @@ fn pen(r: Bytes) -> Option<Obj> {
off += 4 + (r.u32(off)? as usize).min(1 << 20);
}
}
let color = brush(r, off)?.color();
// A pen whose texture brush was not read is counted like a lost brush object.
let Some(fill) = brush(r, off) else {
return lost_texture(r.tail(off)?).then_some(Obj::LostBrush);
};
let color = fill.color();
Some(Obj::Pen { color, width: if width.is_finite() { width.clamp(0.0, 1.0e5) } else { 0.0 } })
}
@@ -1143,11 +1229,13 @@ fn path(r: Bytes) -> Option<Vec<Op>> {
/// rectangle).
fn region(r: Bytes) -> Option<Obj> {
let mut work = 0;
region_node(r, 8, 0, &mut work).map(|(a, _)| Obj::Region(a))
region_node(r, 8, 0, &mut work).map(|(a, _, inexact)| Obj::Region(a, inexact))
}
/// One region node at `off`: its area and its length in bytes.
fn region_node(r: Bytes, off: usize, depth: usize, work: &mut usize) -> Option<(Area, usize)> {
/// One region node at `off`: its area, its length in bytes, and whether the area differs from the
/// node's (a path that is not one convex figure, an intersection that ran out of work, a union
/// drawn larger, or an XOR, exclude or complement node).
fn region_node(r: Bytes, off: usize, depth: usize, work: &mut usize) -> Option<(Area, usize, bool)> {
*work = work.checked_add(1)?;
if depth > MAX_REGION_DEPTH || *work > MAX_REGION_WORK {
return None;
@@ -1155,7 +1243,7 @@ fn region_node(r: Bytes, off: usize, depth: usize, work: &mut usize) -> Option<(
match r.u32(off)? {
0x1000_0000 => {
let [x, y, w, h] = floats::<4>(r, off + 4)?;
Some((Some(rect_poly([x.min(x + w), y.min(y + h), x.max(x + w), y.max(y + h)])), 20))
Some((Some(rect_poly([x.min(x + w), y.min(y + h), x.max(x + w), y.max(y + h)])), 20, false))
}
0x1000_0001 => {
let size = r.u32(off + 4)? as usize;
@@ -1168,53 +1256,118 @@ fn region_node(r: Bytes, off: usize, depth: usize, work: &mut usize) -> Option<(
if *work > MAX_REGION_WORK {
return None;
}
let area = area_of_ops(&path(data)?);
Some((Some(area), 8usize.checked_add(size)?))
let (area, inexact) = area_of_ops(&path(data)?);
Some((Some(area), 8usize.checked_add(size)?, inexact))
}
0x1000_0002 => Some((Some(Vec::new()), 4)),
0x1000_0003 => Some((None, 4)),
0x1000_0002 => Some((Some(Vec::new()), 4, false)),
0x1000_0003 => Some((None, 4, false)),
mode @ 0..=5 => {
let (a, la) = region_node(r, off + 4, depth + 1, work)?;
let (b, lb) = region_node(r, off.checked_add(4 + la)?, depth + 1, work)?;
let out = match mode {
0 => b,
1 => area_intersect(a, b),
2 => area_union(a, b),
// XOR, exclude, complement: the left area bounds the result closely enough.
_ => a,
let (a, la, ia) = region_node(r, off + 4, depth + 1, work)?;
let (b, lb, ib) = region_node(r, off.checked_add(4 + la)?, depth + 1, work)?;
let (out, inexact) = match mode {
0 => (b, ib),
1 => {
let stand_in = intersect_inexact(&a, ia, &b, ib);
let (out, cut_short) = area_intersect(a, b);
(out, stand_in || cut_short)
}
2 => {
let inexact = union_inexact(&a, ia, &b, ib) || union_grows(&a, &b);
(area_union(a, b), inexact)
}
// XOR, exclude, complement: the left area bounds the result closely enough. It is the
// result when the right area is empty under XOR, when either is empty under exclude,
// and when both are empty under complement (the right area outside the left).
_ => {
let (ea, eb) = (!ia && !encloses(&a), !ib && !encloses(&b));
let exact = match mode {
3 => !ia && eb,
4 => (!ia && eb) || ea,
_ => ea && eb,
};
(a, !exact)
}
};
Some((out, (4 + la).checked_add(lb)?))
Some((out, (4 + la).checked_add(lb)?, inexact))
}
_ => None,
}
}
/// The area a path encloses: its outline when that is one convex figure, else the rectangle
/// around it.
fn area_of_ops(ops: &[Op]) -> Vec<P> {
/// The area a path encloses: its outline when that is one convex figure, none when its figures all
/// lie on a line, else the rectangle around it. The flag is set when the rectangle stands in for
/// the path.
fn area_of_ops(ops: &[Op]) -> (Vec<P>, bool) {
if !crate::geom::encloses_area(ops) {
return (Vec::new(), false);
}
let subs = flatten(ops);
if let [(pts, _)] = subs.as_slice()
&& let Some(c) = convex(pts)
{
return c;
return (c, false);
}
ops_bbox(ops).map(rect_poly).unwrap_or_default()
(ops_bbox(ops).map(rect_poly).unwrap_or_default(), true)
}
fn area_intersect(a: Area, b: Area) -> Area {
/// Two areas' intersection, and whether it ran out of work and kept the first area instead.
fn area_intersect(a: Area, b: Area) -> (Area, bool) {
match (a, b) {
(None, x) | (x, None) => x,
(None, x) | (x, None) => (x, false),
(Some(a), Some(b)) if a.len() >= 3 && b.len() >= 3 => {
// Out of work: keep the area so far rather than call the region empty.
match clip_polygon_within(&a, &b, &mut { MAX_AREA_CLIP_WORK }) {
Some(p) => Some(convex(&p).unwrap_or_default()),
None => Some(a),
Some(p) => (Some(convex(&p).unwrap_or_default()), false),
None => (Some(a), true),
}
}
_ => Some(Vec::new()),
_ => (Some(Vec::new()), false),
}
}
/// Whether an area encloses nothing.
fn is_empty(pts: &[P]) -> bool {
pts.len() < 3 || poly_area(pts) <= 0.0
}
/// Whether an area (None: unlimited) encloses some.
fn encloses(a: &Area) -> bool {
a.as_ref().is_none_or(|pts| !is_empty(pts))
}
/// Whether the intersection of two areas, each flagged when it stands in for the file's, can differ
/// from the file's: a stand-in does not matter when the other area is exact and empty.
fn intersect_inexact(a: &Area, ia: bool, b: &Area, ib: bool) -> bool {
(ia && (ib || encloses(b))) || (ib && (ia || encloses(a)))
}
/// Whether the union of two areas, each flagged when it stands in for the file's, can differ from
/// the file's: a stand-in does not matter when the other area is exact and unlimited.
fn union_inexact(a: &Area, ia: bool, b: &Area, ib: bool) -> bool {
(ia && (ib || b.is_some())) || (ib && (ia || a.is_some()))
}
/// Whether the rectangle [`area_union`] draws for two areas is larger than their union.
fn union_grows(a: &Area, b: &Area) -> bool {
let (Some(a), Some(b)) = (a, b) else { return false };
if a.len() < 3 || b.len() < 3 {
return false;
}
let all: Vec<P> = a.iter().chain(b).copied().collect();
let Some([l, t, r, bottom]) = pts_bbox(&all) else { return false };
// Out of work: the overlap is unknown, so the rectangle may be larger.
let Some(overlap) = clip_polygon_within(a, b, &mut { MAX_AREA_CLIP_WORK }) else { return true };
let union = poly_area(a) + poly_area(b) - poly_area(&overlap);
let rect = (r - l) * (bottom - t);
rect > union + 1e-9 * rect
}
/// The area a polygon encloses, whatever its orientation.
fn poly_area(pts: &[P]) -> f64 {
let twice: f64 = pts.iter().zip(pts.iter().cycle().skip(1)).map(|(a, b)| a.0 * b.1 - b.0 * a.1).sum();
(twice / 2.0).abs()
}
fn area_union(a: Area, b: Area) -> Area {
match (a, b) {
(Some(a), Some(b)) => {
@@ -1313,7 +1466,41 @@ fn metafile(r: Bytes) -> Option<Picture> {
NESTING.with(|n| n.set(depth + 1));
let pic = crate::parse_nested(data).ok();
NESTING.with(|n| n.set(depth));
pic.filter(|p| p.width > 0.0 && p.height > 0.0)
pic
}
/// The size in pixels of a bitmap image object, read from its header (a compressed one's from the
/// image file's header) even when its pixels are not, so a draw whose source rectangle selects none
/// of them, or of a bitmap without pixels, is not counted as lost.
fn bitmap_size(r: Bytes) -> Option<(usize, usize)> {
if r.u32(4)? != 1 {
return None;
}
if r.u32(24)? == 1 {
crate::dib::compressed_size(r.tail(28)?.0)
} else {
Some((usize::try_from(r.i32(8)?).ok()?, usize::try_from(r.i32(12)?).ok()?))
}
}
/// Whether a brush object that did not parse is a texture brush (type 2) with an image to draw: its
/// image is a metafile, is not readable, or is a bitmap whose header gives it pixels.
fn lost_texture(r: Bytes) -> bool {
if r.u32(4) != Some(2) {
return false;
}
let image = r.tail(8).and_then(|d| {
let off = if d.u32(0)? & 0x2 != 0 { 32 } else { 8 };
d.tail(off)
});
!image.and_then(bitmap_size).is_some_and(|(w, h)| w == 0 || h == 0)
}
/// The source rectangle of DrawImage or DrawImagePoints in pixels; all zeros (the whole image) when
/// it is given in another unit.
fn source_px(r: Bytes) -> Option<[i64; 4]> {
let [sx, sy, sw, sh] = floats::<4>(r, 8)?;
Some(if r.u32(4)? == 2 { [sx, sy, sw, sh].map(|v| v.round().clamp(-1.0e9, 1.0e9) as i64) } else { [0; 4] })
}
/// Bytes the items of a nested picture own: path segments, dashes, clip rectangles, pixels and
@@ -1641,6 +1828,30 @@ mod cost_tests {
assert!(plus.objects[0].is_some());
}
#[test]
fn an_image_or_texture_past_the_byte_budget_is_counted() {
let (mut plus, mut cv) = (Plus::new(), Canvas::new());
let img = || Rgba { w: 4, h: 4, px: vec![0; 64] };
plus.store(0, Some(Obj::Image(Arc::new(ImageData::Bitmap(img())))), crate::MAX_BYTES);
assert!(matches!(plus.objects[0], Some(Obj::LostImage(Some((4, 4))))));
// DrawImage data: image attributes, source unit (pixels), source rectangle, destination.
let draw = |sx: f32| {
let floats = [sx, 0.0, 1.0, 1.0, 0.0, 0.0, 9.0, 9.0].map(f32::to_le_bytes).concat();
[0u32.to_le_bytes().to_vec(), 2u32.to_le_bytes().to_vec(), floats].concat()
};
assert!(plus.image(&mut cv, 0, Bytes(&draw(10.0))).is_none());
assert_eq!(cv.dropped_images, 0, "a source rectangle beside the pixels draws nothing");
assert!(plus.image(&mut cv, 0, Bytes(&draw(0.0))).is_none());
assert_eq!(cv.dropped_images, 1);
let texture = Fill::Texture { img: Arc::new(img()), wrap: 0, xf: IDENTITY };
plus.store(1, Some(Obj::Brush(texture.clone())), crate::MAX_BYTES);
assert!(plus.objects[1].is_none());
assert_eq!(plus.lost_brushes, 1);
plus.store(1, Some(Obj::Brush(texture)), 0);
assert!(plus.objects[1].is_some());
assert_eq!(plus.lost_brushes, 1);
}
#[test]
fn pieces_of_a_continued_object_count_against_the_shared_budget() {
let (mut plus, mut cv) = (Plus::new(), Canvas::new());
+27
View File
@@ -13,6 +13,33 @@ pub(crate) enum Op {
Z,
}
/// Whether a path can enclose some area: one of its figures has points (curve control points
/// included) that do not all lie on one line.
pub(crate) fn encloses_area(ops: &[Op]) -> bool {
// The figure's first point and its first point elsewhere.
let (mut first, mut second): (Option<P>, Option<P>) = (None, None);
for op in ops {
let pts = match *op {
Op::M(p) => {
(first, second) = (None, None);
[Some(p), None, None]
}
Op::L(p) => [Some(p), None, None],
Op::C(a, b, c) => [Some(a), Some(b), Some(c)],
Op::Z => [None; 3],
};
for c in pts.into_iter().flatten() {
match (first, second) {
(None, _) => first = Some(c),
(Some(a), None) if c != a => second = Some(c),
(Some(a), Some(b)) if ((b.0 - a.0) * (c.1 - a.1) - (b.1 - a.1) * (c.0 - a.0)).abs() > 0.0 => return true,
_ => {}
}
}
}
false
}
pub(crate) fn rect(l: f64, t: f64, r: f64, b: f64) -> Vec<Op> {
vec![Op::M((l, t)), Op::L((r, t)), Op::L((r, b)), Op::L((l, b)), Op::Z]
}
+38 -7
View File
@@ -14,7 +14,8 @@
//! bounds-checked and every count is capped; hostile input yields a shorter picture or an [`Error`],
//! never a panic. Records follow MS-WMF, MS-EMF and MS-EMFPLUS; the README lists the records read
//! and the limits. Records of a type the reader does not know are counted in
//! [`Picture::skipped_records`].
//! [`Picture::skipped_records`]; a parse stopped at a limit, images left out, clips not applied and
//! raster operations not played are reported in the other `Picture` fields.
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
#![forbid(unsafe_code)]
@@ -69,8 +70,38 @@ pub struct Picture {
pub height: f32,
pub items: Vec<Item>,
/// Records of a type the reader does not know (neither drawn nor known to change nothing that
/// is kept). A caller can tell its user that part of the file was not read.
/// is kept). A caller can tell its user that part of the file was not read. An EMF+ metafile
/// image adds the records skipped inside it once, the first time it is drawn.
pub skipped_records: u32,
/// The parse stopped at one of the reader's limits (items, bytes kept, `SAVEDC` depth, clip
/// paths; see the README) before the end of the file, or a metafile image drawn inside it did:
/// the picture holds what came before. The limits that cut one path, string, region or dash
/// pattern short do not set it.
pub truncated: bool,
/// Images the file asks to draw that the reader did not read: bitmaps past a size, item, byte or
/// decode limit or in a form the reader cannot decode, EMF+ metafile images that do not parse or
/// are nested deeper than 3 levels, and pattern or texture brushes whose bitmap was not read, a
/// pen's brush included (counted when the brush or pen is created). An image whose source rectangle selects none of its pixels, or that
/// has no pixels, draws nothing and is not counted. Bitmaps left out while clipping to an EMF+
/// clip (see the README's limits) are not counted here.
pub dropped_images: u32,
/// Clip changes the reader does not apply as the file asks: GDI clip paths selected with
/// `RGN_OR`, `RGN_XOR` or `RGN_DIFF` and EMF+ clips combined with XOR, exclude or complement,
/// which leave the clip as it was; EMF+ unions, drawn as the rectangle around both areas; and
/// EMF+ clips whose area stands in for the one the file gives (a path that is not one convex
/// figure, drawn as its rectangle, or a region built with XOR, exclude or complement).
/// Drawing after them may show more or less than the file asks. A change that cannot alter the
/// clip is not counted: an area whose figures all lie on a line (except in an EMF+ complement of
/// a clip that encloses some area, which would empty it), a GDI `RGN_OR` on a clip that is still
/// the whole surface, and an EMF+ union whose rectangle is no larger than the union. The reader
/// does not work out whether a GDI path changes a clip that is already set, so such a path is
/// counted.
pub ignored_clips: u32,
/// Raster operations the reader does not play: bitmaps drawn as plain copies of their source
/// because their operation is not `SRCCOPY`, `SRCAND`, `SRCPAINT` or `SRCINVERT`, and operations
/// that take no source bitmap (such as `DSTINVERT` or `PATINVERT`) and are left out. `PATCOPY`,
/// `BLACKNESS` and `WHITENESS` are played.
pub unplayed_raster_ops: u32,
}
/// How the ends of an open stroke and of its dashes are drawn (`PS_ENDCAP_*`).
@@ -228,10 +259,10 @@ pub(crate) fn parse_nested(bytes: &[u8]) -> Result<Picture, Error> {
} else {
return Err(Error::NotMetafile);
};
let skipped = cv.skipped;
let mut pic = build(cv.items, frame);
pic.skipped_records = skipped;
Ok(pic)
let (skipped, truncated) = (cv.skipped, cv.full() || cv.truncated_inside);
let (dropped_images, ignored_clips, unplayed_raster_ops) = (cv.dropped_images, cv.ignored_clips, cv.unplayed_raster_ops);
let pic = build(cv.items, frame);
Ok(Picture { skipped_records: skipped, truncated, dropped_images, ignored_clips, unplayed_raster_ops, ..pic })
}
/// True when the bytes start like a WMF (placeable or plain header) or an EMF.
@@ -367,7 +398,7 @@ fn build(raw: Vec<Raw>, frame: Option<Frame>) -> Picture {
}
});
let items = items.collect();
Picture { width: f(size.0).unwrap_or(0.0), height: f(size.1).unwrap_or(0.0), items, skipped_records: 0 }
Picture { width: f(size.0).unwrap_or(0.0), height: f(size.1).unwrap_or(0.0), items, ..Picture::default() }
}
/// An item's clip in picture units: the region rectangles and the clip paths.
+41 -9
View File
@@ -299,6 +299,9 @@ fn item_cap_stops_the_parse_and_keeps_the_rest() {
let recs: Vec<Vec<u8>> = (0..MAX_ITEMS + 10).map(|_| rect.clone()).collect();
let p = parse(&wmf(&recs, None)).unwrap();
assert_eq!(p.items.len(), MAX_ITEMS);
assert!(p.truncated);
let p = parse(&wmf(&recs[..MAX_ITEMS], None)).unwrap();
assert_eq!((p.items.len(), p.truncated), (MAX_ITEMS, false), "exactly the cap is not past it");
}
#[test]
@@ -483,6 +486,34 @@ fn canvas_stops_at_the_byte_budget() {
assert_eq!(cv.items.len(), 2);
}
#[test]
fn a_bitmap_the_byte_budget_refuses_is_counted_once() {
let img = || Rgba { w: 4, h: 4, px: vec![0u8; 64] };
let diamond = || Some(vec![(2.0, 0.0), (4.0, 2.0), (2.0, 4.0), (0.0, 2.0)]);
let mut cv = Canvas::new();
cv.set_clip(diamond());
cv.bitmap([0.0, 0.0, 4.0, 4.0], img());
assert!(!cv.full() && !cv.items.is_empty() && cv.dropped_images == 0, "a bitmap that is kept");
// The clip cuts the bitmap into pieces, and none of them fits: one image is counted.
let mut cv = Canvas::new();
cv.hold(MAX_BYTES - 1);
cv.set_clip(diamond());
cv.bitmap([0.0, 0.0, 4.0, 4.0], img());
assert!(cv.full() && cv.items.is_empty());
assert_eq!(cv.dropped_images, 1);
// A clip that leaves none of the bitmap refuses nothing.
let mut cv = Canvas::new();
cv.hold(MAX_BYTES - 1);
cv.set_clip(Some(vec![(100.0, 100.0), (110.0, 100.0), (110.0, 110.0)]));
cv.bitmap([0.0, 0.0, 4.0, 4.0], img());
assert!(!cv.full() && cv.dropped_images == 0);
// A bitmap drawn with a raster operation is counted the same way.
let mut cv = Canvas::new();
cv.hold(MAX_BYTES - 1);
cv.bitmap_rop([0.0, 0.0, 4.0, 4.0], img(), 0x00CC_0020);
assert!(cv.full() && cv.dropped_images == 1 && cv.unplayed_raster_ops == 0);
}
#[test]
fn oversized_dib_header_size_is_rejected_without_overflow() {
let mut info = info_header(2, 2, 24, 16);
@@ -906,7 +937,7 @@ fn place_fits_the_frame_scales_strokes_and_drops_far_paths() {
clips: Vec::new(),
},
],
skipped_records: 0,
..Default::default()
};
let placed = pic.place(kurbo::Rect::new(0.0, 0.0, 200.0, 100.0), [0.0; 4]);
assert_eq!(placed.len(), 1);
@@ -931,7 +962,7 @@ fn a_huge_pen_is_held_to_what_covers_the_frame() {
region: None,
clips: Vec::new(),
}],
skipped_records: 0,
..Default::default()
};
match pic.place(kurbo::Rect::new(0.0, 0.0, 200.0, 100.0), [0.0; 4]).first() {
Some(crate::PlacedItem::Path { stroke, .. }) => stroke.map(|s| s.1),
@@ -950,7 +981,7 @@ fn a_huge_pen_is_held_to_what_covers_the_frame() {
fn crop_window_keeps_a_sliver_and_stays_finite() {
let [x, y, w, h] = crate::crop_window([0.0, 0.51771, 0.0, 0.45485]);
assert!(x == 0.0 && w == 1.0 && (y - 0.51771).abs() < 1e-6 && (h - 0.02744).abs() < 1e-5, "{y} {h}");
let pic = crate::Picture { width: 100.0, height: 1000.0, items: Vec::new(), skipped_records: 0 };
let pic = crate::Picture { width: 100.0, height: 1000.0, items: Vec::new(), ..Default::default() };
let tf = pic.fit(kurbo::Rect::new(0.0, 0.0, 100.0, 27.44), [0.0, 0.51771, 0.0, 0.45485]).unwrap();
// The kept band of the source (517.71..545.15) is the frame (0..27.44).
let top = tf * kurbo::Point::new(0.0, 517.71);
@@ -979,7 +1010,7 @@ fn crop_window_with_negative_sides_pads_the_source() {
let [x, _, w, _] = crate::crop_window([f32::MIN, 0.0, -1e9, 0.0]);
assert!(x == -100.0 && w == 201.0, "{x} {w}");
// The source sits in the middle half of the frame.
let pic = crate::Picture { width: 100.0, height: 50.0, items: Vec::new(), skipped_records: 0 };
let pic = crate::Picture { width: 100.0, height: 50.0, items: Vec::new(), ..Default::default() };
let tf = pic.fit(kurbo::Rect::new(0.0, 0.0, 100.0, 100.0), [0.0, -0.5, 0.0, -0.5]).unwrap();
let (top, bottom) = (tf * kurbo::Point::new(0.0, 0.0), tf * kurbo::Point::new(100.0, 50.0));
assert!((top.y - 25.0).abs() < 1e-9 && (bottom.y - 75.0).abs() < 1e-9 && (bottom.x - 100.0).abs() < 1e-9, "{top:?} {bottom:?}");
@@ -1012,7 +1043,7 @@ fn the_narrowest_crop_on_the_largest_frame_keeps_its_content() {
clips: Vec::new(),
},
],
skipped_records: 0,
..Default::default()
};
let frame = kurbo::Rect::new(1584.0, 1584.0, 5584.0, 5584.0);
// The last sliver, the first sliver, and sides that overlap.
@@ -1039,7 +1070,7 @@ fn place_counts_the_items_own_clip_region_before_keeping_it() {
let region = || Some(vec![[0.0, 0.0, 50.0, 25.0], [10.0, 10.0, 20.0, 20.0]]);
let frame = kurbo::Rect::new(0.0, 0.0, 100.0, 50.0);
let placed = |second: Item| {
let pic = crate::Picture { width: 100.0, height: 50.0, items: vec![path(segs.clone(), None), second], skipped_records: 0 };
let pic = crate::Picture { width: 100.0, height: 50.0, items: vec![path(segs.clone(), None), second], ..Default::default() };
pic.place(frame, [0.0; 4]).len()
};
let small = vec![Seg::Move(0.0, 0.0), Seg::Line(1.0, 1.0)];
@@ -1070,7 +1101,7 @@ fn place_expands_a_clip_region_once_for_the_items_that_share_it() {
region: Some(region.clone()),
clips: Vec::new(),
};
let pic = crate::Picture { width: 100.0, height: 50.0, items: (0..2000).map(|_| item()).collect(), skipped_records: 0 };
let pic = crate::Picture { width: 100.0, height: 50.0, items: (0..2000).map(|_| item()).collect(), ..Default::default() };
let placed = pic.place(kurbo::Rect::new(0.0, 0.0, 100.0, 50.0), [0.0; 4]);
assert_eq!(placed.len(), 2000);
let regions: Vec<_> = placed
@@ -1096,7 +1127,7 @@ fn place_keeps_only_finite_bounded_bitmaps_with_area() {
bitmap([0.0, 0.0, f32::INFINITY, 10.0]),
bitmap([10.0, 5.0, 10.0, 10.0]),
],
skipped_records: 0,
..Default::default()
};
let placed = pic.place(kurbo::Rect::new(0.0, 0.0, 200.0, 100.0), [0.0; 4]);
assert_eq!(placed.len(), 1);
@@ -1249,7 +1280,7 @@ fn take_pixels_returns_only_drawable_bitmaps() {
clips: Vec::new(),
};
assert_eq!(path.take_pixels(), None);
let pic = |width: f32, height: f32| crate::Picture { width, height, items: Vec::new(), skipped_records: 0 };
let pic = |width: f32, height: f32| crate::Picture { width, height, items: Vec::new(), ..Default::default() };
assert!(pic(1.0, 2.0).has_size());
assert!(!pic(0.0, 2.0).has_size() && !pic(f32::NAN, 2.0).has_size() && !pic(1.0, f32::INFINITY).has_size());
}
@@ -1908,6 +1939,7 @@ fn pattern_brush_pixels_count_against_the_byte_budget() {
recs.push(wrec(0x041B, &cat(vec![h16(9), h16(9), h16(0), h16(0)])));
let p = wmf200(&recs);
assert!(p.items.is_empty(), "the parse stopped at the budget: {:?}", p.items.len());
assert!(p.truncated);
}
fn item_region(item: &Item) -> Option<&[[f32; 4]]> {
+80 -1
View File
@@ -60,7 +60,7 @@ fn placing_stops_at_the_element_cap() {
region: None,
clips: Vec::new(),
};
let pic = crate::Picture { width: 10.0, height: 10.0, items: (0..8).map(|_| path()).collect(), skipped_records: 0 };
let pic = crate::Picture { width: 10.0, height: 10.0, items: (0..8).map(|_| path()).collect(), ..Default::default() };
let placed = pic.place(kurbo::Rect::new(0.0, 0.0, 10.0, 10.0), [0.0; 4]);
// Five paths of 100,001 elements reach the 500,000 cap; the rest are left out.
assert_eq!(placed.len(), 5);
@@ -102,6 +102,85 @@ fn metafiles_nest_only_so_deep() {
assert_eq!(nested(emfplus::MAX_NESTING + 1), 0, "the innermost picture is not read");
}
#[test]
fn emfplus_images_that_are_not_read_are_counted() {
let square = || emf(&[erec(43, &cat(vec![e32(0), e32(0), e32(10), e32(10)]))], [0; 4], [0; 4]);
let nested = |levels: usize| {
let mut file = square();
for _ in 0..levels {
file = wrap(file);
}
parse(&file).unwrap()
};
assert_eq!(nested(emfplus::MAX_NESTING).dropped_images, 0);
assert_eq!(nested(emfplus::MAX_NESTING + 1).dropped_images, 1, "the picture past the nesting cap");
// A bitmap image object whose pixels run past the record.
let obj = cat(vec![h32(0xDBC0_1002), h32(1), h32(4), h32(4), h32(16), h32(0x0026_200A), h32(0), vec![1, 2, 3]]);
let file = emf(&[plus_comment(&[plus_header(false), prec(0x4008, 0x0500 | 2, &obj), draw_image(2, [0.0, 0.0, 40.0, 20.0])])], [0; 4], [0; 4]);
assert_eq!(parse(&file).unwrap().dropped_images, 1);
// The same object drawn from a source rectangle beside its 4 x 4 pixels selects none of them.
let beside = prec(0x401A, 2, &cat(vec![h32(0), h32(2), f32s(&[50.0, 0.0, 1.0, 1.0]), f32s(&[0.0, 0.0, 40.0, 20.0])]));
let file = emf(&[plus_comment(&[plus_header(false), prec(0x4008, 0x0500 | 2, &obj), beside])], [0; 4], [0; 4]);
assert_eq!(parse(&file).unwrap().dropped_images, 0);
// What a nested picture leaves out is reported by the file that draws it.
let inner = emf(&[stretch_bad_png(), erec(43, &cat(vec![e32(0), e32(0), e32(10), e32(10)]))], [0; 4], [0; 4]);
assert_eq!(parse(&inner).unwrap().dropped_images, 1);
assert_eq!(parse(&wrap(inner)).unwrap().dropped_images, 1);
}
#[test]
fn a_metafile_image_adds_its_counts_once_per_object() {
// A square and one record of a type the reader does not know.
let inner = emf(&[erec(43, &cat(vec![e32(0), e32(0), e32(10), e32(10)])), erec(200, &[0; 8])], [0; 4], [0; 4]);
let obj = cat(vec![h32(0xDBC0_1002), h32(2), h32(3), h32(inner.len() as u32), inner]);
let draw = || draw_image(3, [0.0, 0.0, 40.0, 20.0]);
let store = || prec(0x4008, 0x0500 | 3, &obj);
let skipped = |recs: Vec<Vec<u8>>| {
let mut all = vec![plus_header(false)];
all.extend(recs);
let p = parse(&emf(&[plus_comment(&all)], [0; 4], [0; 4])).unwrap();
(p.items.len(), p.skipped_records)
};
assert_eq!(skipped(vec![store()]), (0, 0), "an image that is never drawn");
let cut = prec(0x401A, 3, &cat(vec![h32(0), h32(2), f32s(&[0.0, 0.0, 2.0, 2.0])]));
assert_eq!(skipped(vec![store(), cut]), (0, 0), "a draw record without its destination");
assert_eq!(skipped(vec![store(), draw()]), (1, 1));
assert_eq!(skipped(vec![store(), draw(), draw(), draw()]), (3, 1), "drawn three times, counted once");
assert_eq!(skipped(vec![store(), draw(), store(), draw()]), (2, 2), "stored again, counted again");
}
#[test]
fn a_nested_picture_stopped_at_a_limit_truncates_the_file_that_draws_it() {
// The square comes first, so the inner picture has a size and is drawn.
let inner = |saves: usize| {
let mut recs = vec![erec(43, &cat(vec![e32(0), e32(0), e32(10), e32(10)]))];
recs.extend(vec![erec(33, &[]); saves]);
emf(&recs, [0; 4], [0; 4])
};
assert!(!parse(&wrap(inner(crate::MAX_STACK))).unwrap().truncated);
assert!(parse(&inner(crate::MAX_STACK + 1)).unwrap().truncated);
let p = parse(&wrap(inner(crate::MAX_STACK + 1))).unwrap();
assert!(p.truncated && !p.items.is_empty());
// An inner picture that stops before it draws anything has no size and draws nothing, and still
// reports that it stopped.
let empty = emf(&vec![erec(33, &[]); crate::MAX_STACK + 1], [0; 4], [0; 4]);
let p = parse(&wrap(empty)).unwrap();
assert!(p.truncated && p.items.is_empty());
}
/// EMR_STRETCHDIBITS of a 1 x 1 BI_PNG bitmap whose bits are no image.
fn stretch_bad_png() -> Vec<u8> {
let bits = [1u8, 2, 3, 4];
let mut info = info_header(1, 1, 32, bits.len() as u32);
info[16..20].copy_from_slice(&5u32.to_le_bytes());
let mut payload = vec![0u8; 16];
let fields = [0, 0, 0, 0, 1, 1, 80, 40, 120, bits.len() as i32, 0, 0x00CC_0020, 10, 10];
payload.extend(cat(fields.iter().map(|v| e32(*v)).collect()));
payload.extend(info);
payload.extend(bits);
erec(81, &payload)
}
#[test]
fn emfplus_object_ids_past_the_table_are_ignored() {
let draw = |id: u16| {
+292 -1
View File
@@ -400,6 +400,297 @@ fn a_compressed_dib_over_the_side_cap_is_refused_before_decoding() {
assert!(parse_emf(&[stretch_dibits(crate::MAX_BITMAP_SIDE as i32 + 1, 1, 5, &wide)]).items.is_empty());
}
#[test]
fn bitmaps_that_are_not_read_are_counted() {
let dropped = |recs: &[Vec<u8>]| {
let p = parse_emf(recs);
(p.items.len(), p.dropped_images)
};
assert_eq!(dropped(&[stretch_dibits(3, 1, 5, &png(3, 1, [1, 2, 3, 255]))]), (1, 0), "a bitmap that is drawn");
assert_eq!(dropped(&[stretch_dibits(3, 1, 5, &[1, 2, 3, 4])]), (0, 1), "bits that are no image");
let wide = png(crate::MAX_BITMAP_SIDE + 1, 1, [0; 4]);
assert_eq!(dropped(&[stretch_dibits(crate::MAX_BITMAP_SIDE as i32 + 1, 1, 5, &wide)]), (0, 1), "a side past the cap");
// A source rectangle beside the bitmap selects none of its pixels: nothing to draw, nothing lost.
let mut beside = stretch_dibits(1, 1, 0, &[1, 2, 3, 255]);
beside[32..36].copy_from_slice(&50i32.to_le_bytes());
assert_eq!(dropped(&[beside.clone()]), (0, 0));
// The same for a compression the decoder does not read (BI_RLE8), and counted when it is inside.
beside[80 + 16..80 + 20].copy_from_slice(&1u32.to_le_bytes());
assert_eq!(dropped(&[beside.clone()]), (0, 0));
beside[32..36].copy_from_slice(&0i32.to_le_bytes());
assert_eq!(dropped(&[beside]), (0, 1));
// A BI_PNG header that says 10 x 1 over a 1 x 1 PNG: the PNG is what is cropped.
let mut png_dib = stretch_dibits(10, 1, 5, &png(1, 1, [1, 2, 3, 255]));
png_dib[32..36].copy_from_slice(&5i32.to_le_bytes());
png_dib[40..44].copy_from_slice(&1i32.to_le_bytes());
assert_eq!(dropped(&[png_dib]), (0, 0));
// A STRETCHDIBITS without bits is not a bitmap.
assert_eq!(dropped(&[stretch_dibits(1, 1, 0, &[])]), (0, 0));
// WMF: a DIB of a depth the core header does not have.
let core16 = cat(vec![h32(12), h16(2), h16(2), h16(1), h16(16)]);
let p = parse(&stretch_dib(core16)).unwrap();
assert_eq!((p.items.len(), p.dropped_images), (0, 1));
let p = parse(&stretch_dib(dib24_bottom_up())).unwrap();
assert_eq!((p.items.len(), p.dropped_images), (1, 0));
// WMF: BI_RLE8, which the decoder does not read, from beside the bitmap and from inside it.
let mut file = stretch_dib(dib24_bottom_up());
// The 18-byte WMF header, then the record: the DIB starts 28 bytes in, after the source x at 18.
let at = 18 + 28;
assert_eq!(file[at..at + 4], 40u32.to_le_bytes());
file[at + 16..at + 20].copy_from_slice(&1u32.to_le_bytes());
let x_src = at - 10;
file[x_src..x_src + 2].copy_from_slice(&50i16.to_le_bytes());
assert_eq!(parse(&file).unwrap().dropped_images, 0);
file[x_src..x_src + 2].copy_from_slice(&0i16.to_le_bytes());
assert_eq!(parse(&file).unwrap().dropped_images, 1);
// A header that gives the bitmap no pixels draws nothing.
assert_eq!(dropped(&[stretch_dibits(0, 1, 0, &[1, 2, 3, 4])]), (0, 0));
let empty = cat(vec![h32(12), h16(0), h16(2), h16(1), h16(16)]);
assert_eq!(parse(&stretch_dib(empty)).unwrap().dropped_images, 0);
}
/// EMR_CREATEDIBPATTERNBRUSHPT in slot 1 with the DIB `info` and `bits`.
fn dib_pattern_brush(info: &[u8], bits: &[u8]) -> Vec<u8> {
let fields = [1, 0, 32, info.len() as u32, 32 + info.len() as u32, bits.len() as u32];
erec(94, &cat(vec![fields.iter().flat_map(|v| v.to_le_bytes()).collect(), info.to_vec(), bits.to_vec()]))
}
#[test]
fn pattern_and_texture_brushes_that_are_not_read_are_counted() {
let dib = dib24_bottom_up();
let (info, bits) = dib.split_at(40);
assert_eq!(parse_emf(&[dib_pattern_brush(info, bits)]).dropped_images, 0);
// BI_RLE8, which the decoder does not read.
let mut rle = info_header(2, 2, 8, 4);
rle[16..20].copy_from_slice(&1u32.to_le_bytes());
assert_eq!(parse_emf(&[dib_pattern_brush(&rle, &[0; 4])]).dropped_images, 1);
// A tile past the side cap.
let wide = info_header(crate::canvas::MAX_TILE_SIDE as i32 + 1, 1, 24, 0);
let wide_bits = vec![0u8; (crate::canvas::MAX_TILE_SIDE + 1) * 3 + 4];
assert_eq!(parse_emf(&[dib_pattern_brush(&wide, &wide_bits)]).dropped_images, 1);
// A header with no pixels.
assert_eq!(parse_emf(&[dib_pattern_brush(&info_header(0, 2, 24, 0), &[0; 4])]).dropped_images, 0);
// WMF DIBCREATEPATTERNBRUSH.
let wmf_brush = |dib: Vec<u8>| parse(&wmf(&[wrec(0x0142, &cat(vec![h16(5), h16(0), dib]))], None)).unwrap().dropped_images;
assert_eq!(wmf_brush(dib24_bottom_up()), 0);
assert_eq!(wmf_brush(cat(vec![rle.clone(), vec![0; 4]])), 1);
assert_eq!(wmf_brush(info_header(0, 2, 24, 0)), 0);
// An EMF+ texture brush whose bitmap runs past the record, one with no pixels, and one that is read.
let texture = |image: Vec<u8>| {
let brush = cat(vec![h32(0xDBC0_1002), h32(2), h32(0), h32(0), image]);
emf(&[plus_comment(&[plus_header(false), prec(0x4008, 0x0100 | 5, &brush)])], [0; 4], [0; 4])
};
let short = cat(vec![h32(0xDBC0_1002), h32(1), h32(4), h32(4), h32(16), h32(0x0026_200A), h32(0), vec![1, 2, 3]]);
assert_eq!(parse(&texture(short)).unwrap().dropped_images, 1);
let none = cat(vec![h32(0xDBC0_1002), h32(1), h32(0), h32(4), h32(16), h32(0x0026_200A), h32(0)]);
assert_eq!(parse(&texture(none)).unwrap().dropped_images, 0);
assert_eq!(parse(&texture(bitmap_2x2())).unwrap().dropped_images, 0);
// A pen whose brush is such a texture brush.
let pen = |image: Vec<u8>| {
let brush = cat(vec![h32(0xDBC0_1002), h32(2), h32(0), h32(0), image]);
let pen = cat(vec![h32(0xDBC0_1002), h32(0), h32(0), h32(0), f32s(&[1.0]), brush]);
emf(&[plus_comment(&[plus_header(false), prec(0x4008, 0x0200 | 5, &pen)])], [0; 4], [0; 4])
};
let short = cat(vec![h32(0xDBC0_1002), h32(1), h32(4), h32(4), h32(16), h32(0x0026_200A), h32(0), vec![1, 2, 3]]);
assert_eq!(parse(&pen(short)).unwrap().dropped_images, 1);
let none = cat(vec![h32(0xDBC0_1002), h32(1), h32(0), h32(4), h32(16), h32(0x0026_200A), h32(0)]);
assert_eq!(parse(&pen(none)).unwrap().dropped_images, 0);
assert_eq!(parse(&pen(bitmap_2x2())).unwrap().dropped_images, 0);
}
#[test]
fn an_emfplus_image_refused_by_a_limit_is_counted_unless_the_crop_misses_it() {
// A PNG one pixel wider than the compressed-side cap: its header is read, its pixels are not.
let side = crate::dib::MAX_COMPRESSED_SIDE;
let wide = png(side + 1, 1, [0; 4]);
let obj = cat(vec![h32(0xDBC0_1002), h32(1), h32(0), h32(0), h32(0), h32(0), h32(1), wide]);
let drawn = |sx: f32| {
let draw = prec(0x401A, 2, &cat(vec![h32(0), h32(2), f32s(&[sx, 0.0, 1.0, 1.0]), f32s(&[0.0, 0.0, 40.0, 20.0])]));
let p = parse(&emf(&[plus_comment(&[plus_header(false), prec(0x4008, 0x0500 | 2, &obj), draw])], [0; 4], [0; 4])).unwrap();
(p.items.len(), p.dropped_images)
};
assert_eq!(drawn(0.0), (0, 1));
assert_eq!(drawn(side as f32 + 10.0), (0, 0), "a source rectangle past the right edge");
}
#[test]
fn raster_operations_that_are_not_played_are_counted() {
let copied = |rop: u32| {
let mut rec = stretch_dibits(1, 1, 0, &[10, 20, 30, 255]);
rec[68..72].copy_from_slice(&rop.to_le_bytes());
let p = parse_emf(&[rec]);
(p.items.len(), p.unplayed_raster_ops)
};
// SRCCOPY, SRCAND, SRCPAINT and SRCINVERT are played.
for rop in [0x00CC_0020, 0x0088_00C6, 0x00EE_0086, 0x0066_0046] {
assert_eq!(copied(rop), (1, 0), "{rop:#x}");
}
// NOTSRCCOPY and MERGEPAINT are drawn as the source.
assert_eq!(copied(0x0033_0008), (1, 1));
assert_eq!(copied(0x00BB_0226), (1, 1));
// A bitmap that is clipped away is not drawn, so nothing is copied.
let mut rec = stretch_dibits(1, 1, 0, &[10, 20, 30, 255]);
rec[68..72].copy_from_slice(&0x0033_0008u32.to_le_bytes());
let recs = [erec(59, &[]), erec(60, &[]), erec(67, &h32(1)), rec];
assert_eq!(parse_emf(&recs).unplayed_raster_ops, 0);
// WMF STRETCHDIB with NOTSRCCOPY.
let mut file = stretch_dib(dib24_bottom_up());
let at = file.windows(4).position(|w| w == 0x00CC_0020u32.to_le_bytes()).unwrap();
file[at..at + 4].copy_from_slice(&0x0033_0008u32.to_le_bytes());
assert_eq!(parse(&file).unwrap().unplayed_raster_ops, 1);
// Operations without a source: BLACKNESS is played; DSTINVERT and PATINVERT are left out.
let bitblt = |rop: u32| {
let mut payload = vec![0u8; 92];
payload[16..32].copy_from_slice(&cat(vec![e32(0), e32(0), e32(10), e32(10)]));
payload[32..36].copy_from_slice(&rop.to_le_bytes());
let p = parse_emf(&[erec(76, &payload)]);
(p.items.len(), p.unplayed_raster_ops)
};
assert_eq!(bitblt(0x0000_0042), (1, 0));
assert_eq!(bitblt(0x0055_0009), (0, 1));
assert_eq!(bitblt(0x005A_0049), (0, 1));
assert_eq!(bitblt(0x00CC_0020), (0, 0), "a copy without a bitmap draws nothing and leaves nothing out");
// STRETCHDIBITS with an operation without a source fills the destination, with or without bits.
assert_eq!(copied(0x0000_0042), (1, 0), "BLACKNESS with bits");
assert_eq!(copied(0x0055_0009), (0, 1), "DSTINVERT with bits");
let mut bare = stretch_dibits(1, 1, 0, &[]);
bare[68..72].copy_from_slice(&0x00FF_0062u32.to_le_bytes());
assert_eq!(parse_emf(&[bare]).items.len(), 1, "WHITENESS without bits");
// WMF STRETCHDIB with BLACKNESS fills instead of drawing the bitmap.
let mut file = stretch_dib(dib24_bottom_up());
let at = file.windows(4).position(|w| w == 0x00CC_0020u32.to_le_bytes()).unwrap();
file[at..at + 4].copy_from_slice(&0x0000_0042u32.to_le_bytes());
let p = parse(&file).unwrap();
assert!(matches!(p.items.as_slice(), [Item::Path { fill: Some([0, 0, 0, 255]), .. }]), "{:?}", p.items);
let patblt = |rop: u32| {
let p = parse(&wmf(&[wrec(0x061D, &cat(vec![h32(rop), h16(10), h16(10), h16(0), h16(0)]))], None)).unwrap();
(p.items.len(), p.unplayed_raster_ops)
};
assert_eq!(patblt(0x00FF_0062), (1, 0));
assert_eq!(patblt(0x0055_0009), (0, 1));
assert!(!crate::dib::uses_source(0x00F0_0021) && crate::dib::uses_source(0x00CC_0020) && crate::dib::uses_source(0x00BB_0226));
}
#[test]
fn clips_that_are_not_applied_are_counted() {
let ignored = |recs: Vec<Vec<u8>>| parse_emf(&recs).ignored_clips;
let after = |mode: u32| {
let mut recs = clip_to_rect(0, 0, 10, 10, mode);
recs.push(rect(0, 0, 100, 100));
recs
};
assert_eq!(ignored(after(1)), 0, "RGN_AND is applied");
assert_eq!(ignored(after(5)), 0, "RGN_COPY is applied");
assert_eq!(ignored(after(3)), 1, "RGN_XOR");
assert_eq!(ignored(after(4)), 1, "RGN_DIFF");
assert_eq!(ignored(after(2)), 0, "RGN_OR on the whole surface leaves the whole surface");
assert_eq!(ignored(after(0)), 0, "an invalid mode selects nothing");
let mut recs = clip_to_rect(0, 0, 50, 50, 1);
recs.extend(after(2));
assert_eq!(ignored(recs), 1, "RGN_OR on a clip path is counted, whether or not it widens it");
let recs = vec![erec(59, &[]), erec(60, &[]), erec(67, &h32(4)), rect(0, 0, 100, 100)];
assert_eq!(ignored(recs), 0, "an empty path cuts nothing");
let line = vec![erec(59, &[]), move_to(0, 0), line_to(50, 50), move_to(60, 0), erec(60, &[]), erec(67, &h32(3)), rect(0, 0, 100, 100)];
assert_eq!(ignored(line), 0, "a path on one line encloses nothing");
}
#[test]
fn emfplus_clips_that_are_not_applied_are_counted() {
// The combine mode is in bits 8 to 11 of the flags.
let plus = |recs: Vec<Vec<u8>>| {
let mut all = vec![plus_header(false)];
all.extend(recs);
parse(&emf(&[plus_comment(&all)], [0; 4], [0; 4])).unwrap().ignored_clips
};
let clip = |mode: u16, r: [f32; 4]| prec(0x4032, mode << 8, &f32s(&r));
for mode in 3..=5 {
assert_eq!(plus(vec![clip(0, [0.0, 0.0, 50.0, 50.0]), clip(mode, [10.0, 10.0, 10.0, 10.0])]), 1, "mode {mode}");
assert_eq!(plus(vec![clip(mode, [10.0, 10.0, 0.0, 10.0])]), u32::from(mode == 5), "mode {mode} with no area");
let empty_on_clip = vec![clip(0, [0.0, 0.0, 50.0, 50.0]), clip(mode, [10.0, 10.0, 0.0, 10.0])];
assert_eq!(plus(empty_on_clip), u32::from(mode == 5), "mode {mode} with no area on a clip");
}
assert_eq!(plus(vec![clip(0, [0.0, 0.0, 50.0, 50.0]), clip(2, [10.0, 10.0, 10.0, 10.0])]), 0, "a union inside the clip");
assert_eq!(plus(vec![clip(0, [0.0, 0.0, 50.0, 50.0]), clip(2, [60.0, 60.0, 10.0, 10.0])]), 1, "a union apart from it");
assert_eq!(plus(vec![clip(2, [60.0, 60.0, 10.0, 10.0])]), 0, "a union with no clip set");
assert_eq!(plus(vec![clip(0, [0.0, 0.0, 10.0, 10.0]), clip(2, [10.0, 0.0, 10.0, 10.0])]), 0, "a union that is its rectangle");
// A region whose area is a stand-in: an XOR node, unless its right area is empty.
let node = |r: [f32; 4]| cat(vec![h32(0x1000_0000), f32s(&r)]);
let region = |mode: u32, right: Vec<u8>| {
let obj = cat(vec![h32(0xDBC0_1002), h32(2), h32(mode), node([0.0, 0.0, 30.0, 30.0]), right]);
vec![prec(0x4008, 0x0400 | 6, &obj), prec(0x4034, 6, &[])]
};
assert_eq!(plus(region(3, node([10.0, 10.0, 90.0, 90.0]))), 1, "an XOR region");
assert_eq!(plus(region(3, h32(0x1000_0002))), 0, "XOR with an empty region");
let empty_pair = cat(vec![h32(0xDBC0_1002), h32(3), h32(5), h32(0x1000_0002), h32(0x1000_0002)]);
assert_eq!(plus(vec![prec(0x4008, 0x0400 | 6, &empty_pair), prec(0x4034, 6, &[])]), 0, "the complement of two empty regions");
let cut_empty = vec![clip(0, [0.0, 0.0, 0.0, 10.0]), clip(4, [0.0, 0.0, 10.0, 10.0])];
assert_eq!(plus(cut_empty), 0, "an exclude from an empty clip");
assert_eq!(plus(region(1, node([10.0, 10.0, 90.0, 90.0]))), 0, "an intersection");
assert_eq!(plus(region(2, node([30.0, 0.0, 30.0, 30.0]))), 0, "a union that is its rectangle");
assert_eq!(plus(region(2, node([40.0, 40.0, 30.0, 30.0]))), 1, "a union drawn as a larger rectangle");
// A clip path that is not one convex figure is drawn as its rectangle.
let path = |pts: &[f32], types: Vec<u8>| {
let obj = cat(vec![h32(0xDBC0_1002), h32(types.len() as u32), h32(0), f32s(pts), types]);
vec![prec(0x4008, 0x0300 | 9, &obj), prec(0x4033, 9, &[])]
};
assert_eq!(plus(path(&[0.0, 50.0, 50.0, 0.0, 100.0, 50.0, 50.0, 100.0], vec![0, 1, 1, 0x81])), 0, "a convex path");
let l_shape = [0.0, 0.0, 20.0, 0.0, 20.0, 10.0, 10.0, 10.0, 10.0, 20.0, 0.0, 20.0];
assert_eq!(plus(path(&l_shape, vec![0, 1, 1, 1, 1, 0x81])), 1, "an L shape");
// A stand-in that cannot show: intersected with an empty clip, or added to an unlimited one.
let combined = |mode: u16, first: Vec<Vec<u8>>| {
let mut recs = first;
recs.extend(path(&l_shape, vec![0, 1, 1, 1, 1, 0x81]));
let last = recs.len() - 1;
recs[last] = prec(0x4033, (mode << 8) | 9, &[]);
plus(recs)
};
assert_eq!(combined(1, vec![clip(0, [0.0, 0.0, 0.0, 10.0])]), 0, "an L shape inside an empty clip");
assert_eq!(combined(2, Vec::new()), 0, "an L shape added to no clip");
assert_eq!(combined(1, Vec::new()), 1, "an L shape inside no clip");
let inf = h32(0x1000_0003);
let xor = cat(vec![h32(3), node([0.0, 0.0, 30.0, 30.0]), node([10.0, 10.0, 90.0, 90.0])]);
let obj = cat(vec![h32(0xDBC0_1002), h32(4), h32(2), xor, inf]);
assert_eq!(plus(vec![prec(0x4008, 0x0400 | 6, &obj), prec(0x4034, 6, &[])]), 0, "an XOR region added to an unlimited one");
assert_eq!(plus(vec![clip(1, [0.0, 0.0, 50.0, 50.0]), clip(0, [1.0, 1.0, 5.0, 5.0])]), 0, "intersect and replace are applied");
}
#[test]
fn an_emfplus_clip_on_a_diagonal_line_encloses_nothing() {
let fill = prec(0x400A, 0x8000, &cat(vec![h32(0xFF00_0000), h32(1), f32s(&[0.0, 0.0, 100.0, 100.0])]));
let drawn = |clip: Vec<Vec<u8>>| {
let mut all = vec![plus_header(false)];
all.extend(clip);
all.push(fill.clone());
let p = parse(&emf(&[plus_comment(&all)], [0; 4], [0; 4])).unwrap();
(p.items.len(), p.ignored_clips)
};
let line = cat(vec![h32(0xDBC0_1002), h32(2), h32(0), f32s(&[0.0, 0.0, 10.0, 10.0]), vec![0, 1]]);
// SetClipPath with the line replaces the clip with nothing.
assert_eq!(drawn(vec![prec(0x4008, 0x0300 | 9, &line), prec(0x4033, 9, &[])]), (0, 0));
// A region whose one node is the line.
let node = cat(vec![h32(0x1000_0001), h32(line.len() as u32), line]);
let region = cat(vec![h32(0xDBC0_1002), h32(1), node]);
assert_eq!(drawn(vec![prec(0x4008, 0x0400 | 6, &region), prec(0x4034, 6, &[])]), (0, 0));
}
#[test]
fn a_parse_stopped_at_a_limit_is_truncated() {
assert!(!parse_emf(&[rect(0, 0, 10, 10)]).truncated);
// SAVEDC past the stack depth.
let mut recs = vec![erec(33, &[]); crate::MAX_STACK + 1];
recs.push(rect(0, 0, 10, 10));
let p = parse_emf(&recs);
assert!(p.truncated && p.items.is_empty());
let recs = vec![erec(33, &[]); crate::MAX_STACK];
assert!(!parse_emf(&recs).truncated, "a full stack is not past it");
// One clip path past the nesting cap.
let mut recs = Vec::new();
for _ in 0..=MAX_CLIP_PATHS {
recs.extend(clip_to_rect(0, 0, 100, 100, 1));
}
assert!(parse_emf(&recs).truncated);
}
#[test]
fn placed_paths_carry_their_line_style_and_shared_clips() {
let mut recs = clip_to_rect(0, 0, 50, 50, 1);
@@ -429,7 +720,7 @@ fn an_item_under_a_clip_far_off_the_page_is_left_out() {
region: None,
clips,
};
let pic = crate::Picture { width: 10.0, height: 10.0, items: vec![bitmap(vec![clip]), bitmap(Vec::new())], skipped_records: 0 };
let pic = crate::Picture { width: 10.0, height: 10.0, items: vec![bitmap(vec![clip]), bitmap(Vec::new())], ..Default::default() };
let placed = pic.place(kurbo::Rect::new(0.0, 0.0, 10.0, 10.0), [0.0; 4]);
assert_eq!(placed.len(), 1);
}
+34 -8
View File
@@ -156,8 +156,17 @@ fn record(cv: &mut Canvas, func: u16, r: Bytes) {
Some(())
}
0x0142 => {
// A pattern the reader cannot decode still takes its handle slot.
let b = dib_pattern_brush(r).map_or(Obj::Other, Obj::Brush);
// A pattern the reader cannot decode still takes its handle slot, and is counted as a
// dropped image unless it has no pixels.
let b = dib_pattern_brush(r).map_or_else(
|| {
if !pattern_has_no_pixels(r) {
cv.drop_image();
}
Obj::Other
},
Obj::Brush,
);
cv.add_object(None, b);
Some(())
}
@@ -241,6 +250,12 @@ fn dib_pattern_brush(r: Bytes) -> Option<Brush> {
Brush::pattern(img, usage == 1)
}
/// Whether the DIB of a DIBCREATEPATTERNBRUSH record has a readable header that gives it no pixels.
fn pattern_has_no_pixels(r: Bytes) -> bool {
let Some(dib) = r.tail(10) else { return false };
dib::has_no_pixels(dib, dib::info_len(dib).and_then(|n| dib.tail(n)))
}
/// Font object (MS-WMF 2.2.1.2): height, width, escapement, orientation, weight (i16 each), italic,
/// underline, strike-out and charset bytes, three precision/quality bytes, pitch and family, then the
/// face name (up to 32 bytes, NUL-terminated, in the font's character set).
@@ -393,13 +408,24 @@ fn dib_stretchblt(cv: &mut Canvas, r: Bytes) -> Option<()> {
/// A DIB at `at`, stretched from source rectangle `src` into `dst` (both in logical units, pixels for `src`).
/// The raster operation `rop` decides how the pixels combine (see [`dib::prepare`]).
/// A DIB that cannot be read, or is past a limit, is counted as a dropped image. A raster operation
/// that takes no source fills the destination instead (see [`Canvas::fill_rop`]).
fn dib_blit(cv: &mut Canvas, r: Bytes, at: usize, rop: u32, dst: [f64; 4], src: [f64; 4]) -> Option<()> {
let dib = r.tail(at)?;
let n = dib::info_len(dib)?;
let info = dib.slice(0, n)?;
let bits = dib.tail(n)?;
let (mut img, dst) = dib::decode_clip(Bytes(info), bits, false, src.map(|v| v as i64), dst)?;
if !dib::uses_source(rop) {
cv.fill_rop(dst, rop);
return Some(());
}
let dib = r.tail(at).filter(|d| !d.0.is_empty())?;
let src = src.map(|v| v as i64);
let info = dib::info_len(dib).and_then(|n| Some((Bytes(dib.slice(0, n)?), dib.tail(n)?)));
let decoded = info.and_then(|(info, bits)| dib::decode_clip(info, bits, false, src, dst));
let Some((mut img, dst)) = decoded else {
if !dib::crop_misses(dib, info.map(|(_, bits)| bits), src) {
cv.drop_image();
}
return None;
};
dib::prepare(&mut img, dib::Blend::Rop(rop));
cv.bitmap(dst, img);
cv.bitmap_rop(dst, img, rop);
Some(())
}