mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 21:52:32 +00:00
Merge pull request #1918 from dotCooCoo/fix/metafile-report-drops
craft-metafile: report what the reader leaves out
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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());
|
||||
|
||||
@@ -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]
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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]]> {
|
||||
|
||||
@@ -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| {
|
||||
|
||||
@@ -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, ®ion), 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);
|
||||
}
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user